Merge remote-tracking branch 'origin/master'

mitao

8 天以前 2bdcf12109e62a731eb16e90b6e1c39a67853fb1

Merge remote-tracking branch 'origin/master'

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/api/AssetHouseInspectionItemController.java

@@ -1,8 +1,58 @@
package com.ruoyi.web.controller.api;


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.ExcelImportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.afterturn.easypoi.excel.entity.ImportParams;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.TDept;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.WebUtils;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.dto.AddAssetHouseInspection;
import com.ruoyi.system.dto.AddAssetRepairRequestDTO;
import com.ruoyi.system.export.AssetHouseInspectionImport;
import com.ruoyi.system.model.*;
import com.ruoyi.system.query.AssetHouseInspectionRecordListQuery;
import com.ruoyi.system.query.AssetRepairRequestListQuery;
import com.ruoyi.system.service.*;
import com.ruoyi.system.vo.AssetHouseInspectionVO;
import com.ruoyi.system.vo.AssetRepairRequestVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Workbook;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
@@ -14,7 +64,434 @@
 */
@RestController
@RequestMapping("/asset-house-inspection-item")
@Api(tags = {"房屋巡检"})
@Slf4j
public class AssetHouseInspectionItemController {
    @Autowired
    private TokenService tokenService;
    @Autowired
    private ISysUserService sysUserService;
    @Autowired
    private TDeptService deptService;
    @Autowired
    private AssetMainService assetMainService;
    @Autowired
    private AssetTypeService assetTypeService;
    @Autowired
    private AssetHouseInspectionItemService assetHouseInspectionItemService;
    @Autowired
    private AssetHouseInspectionDetailService assetHouseInspectionDetailService;
    @Autowired
    private AssetHouseInspectionRecordService assetHouseInspectionRecordService;
    @Autowired
    private AssetPropertyExtService assetPropertyExtService;

    @ApiOperation("房屋巡检分页列表")
    @PostMapping("/listAll")
    public R<PageInfo<AssetHouseInspectionVO>> listAll(@RequestBody AssetHouseInspectionRecordListQuery query) {
        String deptId = tokenService.getLoginUser().getDeptId();
        List<Integer> deptIds = deptService.getAllSubDeptIds(deptId);
        List<SysUser> sysUsers = sysUserService.selectAllList();
        if (deptIds.isEmpty()) {
            return R.ok(new PageInfo<>());
        } else {
            List<Long> userIds = sysUsers.stream().filter(e -> deptIds.contains(Integer.valueOf(e.getDeptId())))
                    .map(SysUser::getUserId).collect(Collectors.toList());
            if (userIds.isEmpty()) {
                return R.ok(new PageInfo<>());
            }
            if (StringUtils.hasLength(query.getNickName())) {
                List<SysUser> users = sysUsers.stream().filter(e -> e.getNickName().contains(query.getNickName())).collect(Collectors.toList());
                List<Long> queryUserIds = users.stream().map(SysUser::getUserId).collect(Collectors.toList());
                // userIds和queryUserIds取交集
                userIds = userIds.stream().filter(queryUserIds::contains).collect(Collectors.toList());
                if (userIds.isEmpty()) {
                    return R.ok(new PageInfo<>());
                }
            }
            query.setUserIds(userIds);
        }
        PageInfo<AssetHouseInspectionVO> res = assetHouseInspectionRecordService.pageList(query);
        return R.ok(res);
    }
    @ApiOperation(value = "查询资产列表")
    @PostMapping(value = "/listAssetMain")
    public R<List<AssetMain>> listAssetMain() {
        String deptId = tokenService.getLoginUser().getDeptId();
        TDept dept = deptService.getById(tokenService.getLoginUser().getDeptId());
        List<Integer> deptIds = deptService.getAllSubDeptIds(deptId);
        AssetType assetType = assetTypeService.lambdaQuery().like(AssetType::getTypeName, "不动").
                last("limit 1").one();
        if (dept.getDeptName().contains("资产管理")){
            List<AssetMain> list = assetMainService.lambdaQuery()
                    .eq(AssetMain::getAssetTypeId, assetType.getId())
                    .list();
            return R.ok(list);
        }else{
            if (deptIds.isEmpty()){
                return R.ok(new ArrayList<>());
            }else{
                List<AssetMain> list = assetMainService.lambdaQuery()
                        .eq(AssetMain::getAssetTypeId, assetType.getId())
                        .in(AssetMain::getOwnershipDeptId, deptIds).list();
                return R.ok(list);
            }
        }
    }
    @ApiOperation(value = "巡检子项树状结构")
    @PostMapping(value = "/listItem")
    public R<List<AssetHouseInspectionItem>> listItem() {
        // 查询所有未被禁用的巡检项
        List<AssetHouseInspectionItem> allItems = assetHouseInspectionItemService.list(
                new LambdaQueryWrapper<AssetHouseInspectionItem>()
                        .eq(AssetHouseInspectionItem::getDisabled, 0)
        );
        // 构建树形结构
        List<AssetHouseInspectionItem> tree = buildTree(allItems, 0);

        return R.ok(tree);
    }

    /**
     * 构建树形结构
     *
     * @param items    所有巡检项
     * @param parentId 父级ID
     * @return 树形结构列表
     */
    private List<AssetHouseInspectionItem> buildTree(List<AssetHouseInspectionItem> items, int parentId) {
        List<AssetHouseInspectionItem> children = new ArrayList<>();

        for (AssetHouseInspectionItem item : items) {
            if (item.getParentId() != null && item.getParentId() == parentId) {
                // 递归设置子节点
                List<AssetHouseInspectionItem> childItems = buildTree(items, item.getId());
                item.setChildren(childItems);
                children.add(item);
            }
        }

        return children;
    }

    @Log(title = "房屋巡检-新增", businessType = BusinessType.INSERT)
    @ApiOperation(value = "房屋巡检新增")
    @PostMapping(value = "/add")
    @Transactional
    public R add(@RequestBody AddAssetHouseInspection dto) {
        AssetMain assetMain = assetMainService.getById(dto.getAssetMainId());
        AssetPropertyExt assetPropertyExt = assetPropertyExtService.lambdaQuery().eq(AssetPropertyExt::getAssetMainId, assetMain.getId())
                .last("limit 1").one();
        dto.setAssetCode(assetMain.getAssetCode());
        dto.setAssetName(assetMain.getAssetName());
        dto.setRoomNumber(assetPropertyExt.getRoomNumber());
        dto.setInspectionDate(LocalDate.now());
        int userId = tokenService.getLoginUser().getUserId().intValue();
        dto.setInspectionId(userId);
        assetHouseInspectionRecordService.save(dto);
        StringBuilder houseCloseStatus = new StringBuilder();
        StringBuilder waterElectronicGasCloseStatus = new StringBuilder();
        StringBuilder innerStatus = new StringBuilder();
        for (AssetHouseInspectionDetail assetHouseInspectionDetail : dto.getList()) {
            assetHouseInspectionDetail.setInspectionRecordId(dto.getId());
            if (!assetHouseInspectionDetail.getInspectionResult()) {
                if (assetHouseInspectionDetail.getSubItemName().contains("门窗")) {
                    houseCloseStatus.append(assetHouseInspectionDetail.getRemark());
                } else if (assetHouseInspectionDetail.getSubItemName().contains("电表")) {
                    waterElectronicGasCloseStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("气表")) {
                    waterElectronicGasCloseStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("水表")) {
                    waterElectronicGasCloseStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("瓷砖")) {
                    innerStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("墙壁")) {
                    innerStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("设备")) {
                    innerStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                } else if (assetHouseInspectionDetail.getSubItemName().contains("漏水")) {
                    innerStatus.append(assetHouseInspectionDetail.getRemark()).append("|");
                }
            }
        }
        if (StringUtils.hasLength(waterElectronicGasCloseStatus)) {
            waterElectronicGasCloseStatus.deleteCharAt(waterElectronicGasCloseStatus.length() - 1);
        }
        if (StringUtils.hasLength(innerStatus)) {
            innerStatus.deleteCharAt(innerStatus.length() - 1);
        }
        if (StringUtils.hasLength(houseCloseStatus)) {
            dto.setHouseCloseStatus(houseCloseStatus.toString());
        } else {
            dto.setHouseCloseStatus("正常");
        }
        if (StringUtils.hasLength(waterElectronicGasCloseStatus)) {
            dto.setWaterElectronicGasCloseStatus(waterElectronicGasCloseStatus.toString());
        } else {
            dto.setWaterElectronicGasCloseStatus("正常");
        }
        if (StringUtils.hasLength(innerStatus)) {
            dto.setInnerStatus(innerStatus.toString());
        } else {
            dto.setInnerStatus("正常");
        }

        assetHouseInspectionRecordService.updateById(dto);
        assetHouseInspectionDetailService.saveBatch(dto.getList());
        return R.ok();
    }

    @ApiOperation(value = "房屋巡检导入模板下载")
    @GetMapping("/import-template")
    public void importTemplate() {

        List<AssetHouseInspectionImport> assetHouseInspectionImports = new ArrayList<>();
        AssetHouseInspectionImport temp = new AssetHouseInspectionImport();
        assetHouseInspectionImports.add(temp);
        Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(), AssetHouseInspectionImport.class, assetHouseInspectionImports);
        HttpServletResponse response = WebUtils.response();
        ServletOutputStream outputStream = null;
        try {
            String fileName = URLEncoder.encode("房屋巡检导入模板.xls", "utf-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
            response.setHeader("content-Type", "application/vnd.ms-excel");
            response.setHeader("Pragma", "no-cache");
            response.setHeader("Cache-Control", "no-cache");
            outputStream = response.getOutputStream();
            workbook.write(outputStream);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("房屋巡检导入模板下载失败!");
        } finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Log(title = "房屋巡检导入", businessType = BusinessType.INSERT)
    @ApiOperation(value = "房屋巡检导入")
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    @PostMapping("/import")
    public R<String> importLocation(@RequestPart("file") MultipartFile file) {
        Map<String, AssetMain> assetMainMap = assetMainService.list().stream().collect(Collectors.toMap(AssetMain::getAssetCode, assetMain -> assetMain));
        Map<String, SysUser> sysUserMap = sysUserService.selectAllList().stream().collect(Collectors.toMap(SysUser::getNickName, sysUser -> sysUser));
        Map<Integer, AssetPropertyExt> assetPropertyExtMap = assetPropertyExtService.list().stream().collect(Collectors.toMap(AssetPropertyExt::getAssetMainId, assetPropertyExt -> assetPropertyExt));
        List<AssetHouseInspectionItem> allItems = assetHouseInspectionItemService.list(
                new LambdaQueryWrapper<AssetHouseInspectionItem>()
                        .eq(AssetHouseInspectionItem::getDisabled, 0)
        );
        List<AssetHouseInspectionDetail> assetHouseInspectionDetails = new ArrayList<>();
        ImportParams params = new ImportParams();
        params.setHeadRows(1); //表头行数
        InputStream inputStream = null;
        List<AssetHouseInspectionImport> assetHouseInspectionImports;
        try {
            inputStream = file.getInputStream();
            assetHouseInspectionImports = ExcelImportUtil.importExcel(inputStream,
                    AssetHouseInspectionImport.class, params);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("房屋巡检导入失败:{}", e.getMessage());
            throw new ServiceException("房屋巡检导入失败!");
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                throw new ServiceException(e.getMessage());
            }
        }
        if (CollectionUtils.isEmpty(assetHouseInspectionImports)) {
            throw new ServiceException("房屋巡检数据为空!");
        }
        JSONObject result = new JSONObject();
        for (AssetHouseInspectionImport assetHouseInspectionImport : assetHouseInspectionImports) {
            AssetHouseInspectionRecord assetHouseInspectionRecord = new AssetHouseInspectionRecord();
            AssetMain assetMain = assetMainMap.get(assetHouseInspectionImport.getAssetCode());
            if (assetMain==null){
                result.append("根据资产编码：[", assetHouseInspectionImport.getAssetCode()+"]未查询到资产");
                continue;
            }
            assetHouseInspectionRecord.setAssetMainId(assetMain.getId());
            SysUser sysUser = sysUserMap.get(assetHouseInspectionImport.getNickName());
            if (sysUser==null){
                result.append("根据巡检人名称：[", assetHouseInspectionImport.getNickName()+"]未查询到巡检人");
                continue;
            }
            assetHouseInspectionRecord.setInspectionId(sysUser.getUserId().intValue());
            assetHouseInspectionRecord.setAssetCode(assetMain.getAssetCode());
            assetHouseInspectionRecord.setAssetName(assetMain.getAssetName());
            AssetPropertyExt assetPropertyExt = assetPropertyExtMap.get(assetMain.getId());
            if (assetPropertyExt!=null){
                assetHouseInspectionRecord.setRoomNumber(assetPropertyExt.getRoomNumber());
            }
            if (StringUtils.hasLength(assetHouseInspectionImport.getInspectionDate())){
                LocalDate parse = LocalDate.parse(assetHouseInspectionImport.getInspectionDate(), DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                assetHouseInspectionRecord.setInspectionDate(parse);
            }else{
                result.append("未填写巡检日期：[", "未填写巡检日期"+"]");
                continue;
            }


            assetHouseInspectionRecord.setHouseCloseStatus(assetHouseInspectionImport.getHouseCloseStatus());
            AssetHouseInspectionDetail assetHouseInspectionDetail = new AssetHouseInspectionDetail();
            assetHouseInspectionDetail.setInspectionItemId(1);
            assetHouseInspectionDetail.setItemName("房屋关闭情况");
            assetHouseInspectionDetail.setSubItemId(2);
            assetHouseInspectionDetail.setSubItemName("门窗关闭情况");
            assetHouseInspectionDetail.setRemark(assetHouseInspectionImport.getHouseCloseStatus());
            if (assetHouseInspectionImport.getHouseCloseStatus().equals("正常")){
                assetHouseInspectionDetail.setInspectionResult(true);
            }else{
                assetHouseInspectionDetail.setInspectionResult(false);
            }
            assetHouseInspectionDetails.add(assetHouseInspectionDetail);
            String waterStatus1 = assetHouseInspectionImport.getWaterStatus1();
            String waterStatus2 = assetHouseInspectionImport.getWaterStatus2();
            String waterStatus3 = assetHouseInspectionImport.getWaterStatus3();
            assetHouseInspectionRecord.setWaterElectronicGasCloseStatus("正常");
            AssetHouseInspectionDetail assetHouseInspectionDetailWatter1 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailWatter1.setInspectionItemId(3);
            assetHouseInspectionDetailWatter1.setItemName("水电气表关闭情况");
            assetHouseInspectionDetailWatter1.setSubItemId(4);
            assetHouseInspectionDetailWatter1.setSubItemName("水表关闭情况");
            assetHouseInspectionDetailWatter1.setRemark(assetHouseInspectionImport.getWaterStatus1());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailWatter1);

            AssetHouseInspectionDetail assetHouseInspectionDetailWatter2 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailWatter2.setInspectionItemId(3);
            assetHouseInspectionDetailWatter2.setItemName("水电气表关闭情况");
            assetHouseInspectionDetailWatter2.setSubItemId(5);
            assetHouseInspectionDetailWatter2.setSubItemName("气表关闭情况");
            assetHouseInspectionDetailWatter2.setRemark(assetHouseInspectionImport.getWaterStatus2());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailWatter2);

            AssetHouseInspectionDetail assetHouseInspectionDetailWatter3 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailWatter3.setInspectionItemId(3);
            assetHouseInspectionDetailWatter3.setItemName("水电气表关闭情况");
            assetHouseInspectionDetailWatter3.setSubItemId(6);
            assetHouseInspectionDetailWatter3.setSubItemName("电表关闭情况");
            assetHouseInspectionDetailWatter3.setRemark(assetHouseInspectionImport.getWaterStatus3());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailWatter3);
            if (waterStatus1.equals("正常")&&waterStatus2.equals("正常")&&waterStatus3.equals("正常")){
                assetHouseInspectionDetailWatter2.setInspectionResult(true);
                assetHouseInspectionDetailWatter3.setInspectionResult(true);
            }else{
                    StringBuilder stringBuilder = new StringBuilder();
                    if (!waterStatus1.equals("正常")){
                        stringBuilder.append(waterStatus1).append("|");
                        assetHouseInspectionDetailWatter1.setInspectionResult(false);
                    }else{
                        assetHouseInspectionDetailWatter1.setInspectionResult(true);
                    }
                    if (!waterStatus2.equals("正常")){
                        stringBuilder.append(waterStatus2).append("|");
                        assetHouseInspectionDetailWatter2.setInspectionResult(false);
                    }else{
                        assetHouseInspectionDetailWatter2.setInspectionResult(true);
                    }
                    if (!waterStatus3.equals("正常")){
                        stringBuilder.append(waterStatus3).append("|");
                        assetHouseInspectionDetailWatter3.setInspectionResult(false);
                    }else{
                        assetHouseInspectionDetailWatter3.setInspectionResult(true);
                    }
                    if (stringBuilder.length()>0){
                        stringBuilder.deleteCharAt(stringBuilder.length()-1);
                    }
                    assetHouseInspectionRecord.setInnerStatus(stringBuilder.toString());
            }
            String innerStatus1 = assetHouseInspectionImport.getInnerStatus1();
            String innerStatus2 = assetHouseInspectionImport.getInnerStatus2();
            String innerStatus3 = assetHouseInspectionImport.getInnerStatus3();
            String innerStatus4 = assetHouseInspectionImport.getInnerStatus4();
            AssetHouseInspectionDetail assetHouseInspectionDetailInner1 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailInner1.setInspectionItemId(7);
            assetHouseInspectionDetailInner1.setItemName("房屋内部情况");
            assetHouseInspectionDetailInner1.setSubItemId(8);
            assetHouseInspectionDetailInner1.setSubItemName("墙壁漏水情况");
            assetHouseInspectionDetailInner1.setRemark(assetHouseInspectionImport.getWaterStatus1());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailInner1);

            AssetHouseInspectionDetail assetHouseInspectionDetailInner2 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailInner2.setInspectionItemId(7);
            assetHouseInspectionDetailInner2.setItemName("房屋内部情况");
            assetHouseInspectionDetailInner2.setSubItemId(9);
            assetHouseInspectionDetailInner2.setSubItemName("设备损坏情况");
            assetHouseInspectionDetailInner2.setRemark(assetHouseInspectionImport.getWaterStatus2());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailInner2);

            AssetHouseInspectionDetail assetHouseInspectionDetailInner3 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailInner3.setInspectionItemId(7);
            assetHouseInspectionDetailInner3.setItemName("房屋内部情况");
            assetHouseInspectionDetailInner3.setSubItemId(10);
            assetHouseInspectionDetailInner3.setSubItemName("墙壁掉灰情况");
            assetHouseInspectionDetailInner3.setRemark(assetHouseInspectionImport.getWaterStatus3());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailInner3);

            AssetHouseInspectionDetail assetHouseInspectionDetailInner4 = new AssetHouseInspectionDetail();
            assetHouseInspectionDetailInner4.setInspectionItemId(7);
            assetHouseInspectionDetailInner4.setItemName("房屋内部情况");
            assetHouseInspectionDetailInner4.setSubItemId(11);
            assetHouseInspectionDetailInner4.setSubItemName("地瓷砖开裂情况");
            assetHouseInspectionDetailInner4.setRemark(assetHouseInspectionImport.getWaterStatus3());
            assetHouseInspectionDetails.add(assetHouseInspectionDetailInner4);
            if (innerStatus1.equals("正常")&&innerStatus2.equals("正常")&&innerStatus3.equals("正常")&&innerStatus4.equals("正常")){
                assetHouseInspectionRecord.setInnerStatus("正常");
            }else{
                StringBuilder stringBuilder = new StringBuilder();
                if (!innerStatus1.equals("正常")){
                    stringBuilder.append(innerStatus1).append("|");
                    assetHouseInspectionDetailInner1.setInspectionResult(false);
                }else{
                    assetHouseInspectionDetailInner1.setInspectionResult(true);
                }
                if (!innerStatus2.equals("正常")){
                    stringBuilder.append(innerStatus2).append("|");
                    assetHouseInspectionDetailInner1.setInspectionResult(false);
                }else{
                    assetHouseInspectionDetailInner1.setInspectionResult(true);
                }
                if (!innerStatus3.equals("正常")){
                    stringBuilder.append(innerStatus3).append("|");
                    assetHouseInspectionDetailInner1.setInspectionResult(false);
                }else{
                    assetHouseInspectionDetailInner1.setInspectionResult(true);
                }
                if (!innerStatus4.equals("正常")){
                    stringBuilder.append(innerStatus4).append("|");
                    assetHouseInspectionDetailInner1.setInspectionResult(false);
                }else{
                    assetHouseInspectionDetailInner1.setInspectionResult(true);
                }
                if (stringBuilder.length()>0){
                    stringBuilder.deleteCharAt(stringBuilder.length()-1);
                }
                assetHouseInspectionRecord.setInnerStatus(stringBuilder.toString());
            }
            assetHouseInspectionRecord.setRemarks(assetHouseInspectionImport.getRemark());
            assetHouseInspectionRecordService.save(assetHouseInspectionRecord);
            assetHouseInspectionDetails.add(assetHouseInspectionDetail);
            for (AssetHouseInspectionDetail houseInspectionDetail : assetHouseInspectionDetails) {
                houseInspectionDetail.setInspectionRecordId(assetHouseInspectionRecord.getId());
            }
            assetHouseInspectionDetailService.saveBatch(assetHouseInspectionDetails);

        }
        return R.ok();
    }

    @Log(title = "房屋巡检-删除", businessType = BusinessType.DELETE)
    @ApiOperation(value = "房屋巡检-删除")
    @DeleteMapping(value = "/delete")
    public R delete(@RequestParam String ids) {
        assetHouseInspectionDetailService.remove(new LambdaQueryWrapper<AssetHouseInspectionDetail>()
                .in(AssetHouseInspectionDetail::getInspectionRecordId, Arrays.asList(ids.split(","))));
        assetHouseInspectionRecordService.removeBatchByIds(Arrays.asList(ids.split(",")));
        return R.ok();
    }
}


 ruoyi-system/src/main/java/com/ruoyi/system/dto/AddAssetHouseInspection.java

New file
@@ -0,0 +1,21 @@
package com.ruoyi.system.dto;

import com.ruoyi.system.model.*;
import com.ruoyi.system.vo.AssetRepairListVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

@Data
@ApiModel(value = "新增编辑巡检记录DTO")
public class AddAssetHouseInspection extends AssetHouseInspectionRecord {



    @ApiModelProperty(value = "巡检详情列表")
    private List<AssetHouseInspectionDetail> list;


}

 ruoyi-system/src/main/java/com/ruoyi/system/export/AssetHouseInspectionImport.java

New file
@@ -0,0 +1,41 @@
package com.ruoyi.system.export;

import cn.afterturn.easypoi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import lombok.Data;

import java.io.Serializable;

@Data
@ApiModel(value = "房屋巡检导入excel")
public class AssetHouseInspectionImport implements Serializable {

    @Excel(name = "资产编码",width = 20)
    private String assetCode;
    @Excel(name = "资产名称",width = 20)
    private String assetName;
    @Excel(name = "门窗关闭情况",width = 20)
    private String houseCloseStatus;
    @Excel(name = "水表关闭情况",width = 20)
    private String waterStatus1;
    @Excel(name = "气表关闭情况",width = 20)
    private String waterStatus2;
    @Excel(name = "电表关闭情况",width = 20)
    private String waterStatus3;
    @Excel(name = "墙壁漏水情况",width = 20)
    private String innerStatus1;
    @Excel(name = "设备损坏情况",width = 20)
    private String innerStatus2;
    @Excel(name = "墙壁掉灰情况",width = 20)
    private String innerStatus3;
    @Excel(name = "地瓷砖开裂情况",width = 20)
    private String innerStatus4;
    @Excel(name = "巡检备注",width = 20)
    private String remark;
    @Excel(name = "巡检日期",width = 20)
    private String inspectionDate;
    @Excel(name = "巡检人",width = 20)
    private String nickName;


}

 ruoyi-system/src/main/java/com/ruoyi/system/mapper/AssetHouseInspectionRecordMapper.java

@@ -1,7 +1,14 @@
package com.ruoyi.system.mapper;

import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.system.model.AssetHouseInspectionRecord;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.system.query.AssetHouseInspectionRecordListQuery;
import com.ruoyi.system.vo.AssetHouseInspectionVO;
import com.ruoyi.system.vo.AssetRepairRequestVO;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * <p>
@@ -13,4 +20,5 @@
 */
public interface AssetHouseInspectionRecordMapper extends BaseMapper<AssetHouseInspectionRecord> {

    List<AssetHouseInspectionVO> pageList(@Param("query")AssetHouseInspectionRecordListQuery query, @Param("pageInfo")PageInfo<AssetHouseInspectionVO> pageInfo);
}

 ruoyi-system/src/main/java/com/ruoyi/system/model/AssetHouseInspectionItem.java

@@ -12,6 +12,7 @@

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;

/**
 * <p>
@@ -69,6 +70,9 @@
    @TableField("disabled")
    @TableLogic
    private Boolean disabled;
    @ApiModelProperty("子项")
    @TableField(exist = false)
    private List<AssetHouseInspectionItem> children;


}

 ruoyi-system/src/main/java/com/ruoyi/system/model/AssetHouseInspectionRecord.java

@@ -37,6 +37,9 @@
    @ApiModelProperty(value = "资产主表ID，关联asset_main表")
    @TableField("asset_main_id")
    private Integer assetMainId;
    @ApiModelProperty(value = "巡检人id")
    @TableField("inspection_id")
    private Integer inspectionId;

    @ApiModelProperty(value = "资产编号（冗余字段）")
    @TableField("asset_code")
@@ -54,17 +57,17 @@
    @TableField("inspection_date")
    private LocalDate inspectionDate;

    @ApiModelProperty(value = "房屋关闭情况：1-正常、0-异常")
    @ApiModelProperty(value = "新增不传 列表使用 房屋关闭情况  ")
    @TableField("house_close_status")
    private Boolean houseCloseStatus;
    private String houseCloseStatus;

    @ApiModelProperty(value = "水电气关闭情况：1-正常、0-异常")
    @ApiModelProperty(value = "新增不传 列表使用 水电气关闭情况 ")
    @TableField("water_electronic_gas_close_status")
    private Boolean waterElectronicGasCloseStatus;
    private String waterElectronicGasCloseStatus;

    @ApiModelProperty(value = "内部情况：1-正常、0-异常")
    @ApiModelProperty(value = "新增不传 列表使用 内部情况 ")
    @TableField("inner_status")
    private Boolean innerStatus;
    private String innerStatus;

    @ApiModelProperty(value = "巡检备注")
    @TableField("remarks")

 ruoyi-system/src/main/java/com/ruoyi/system/query/AssetHouseInspectionRecordListQuery.java

New file
@@ -0,0 +1,25 @@
package com.ruoyi.system.query;

import com.ruoyi.common.core.domain.BasePage;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

@Data
@ApiModel(value = "房屋巡检分页列表query")
public class AssetHouseInspectionRecordListQuery extends BasePage {

    @ApiModelProperty(value = "巡检人名称")
    private String nickName;
    @ApiModelProperty(value = "资产名称")
    private String assetMainName;
    @ApiModelProperty(value = "开始时间")
    private String startTime;
    @ApiModelProperty(value = "结束时间")
    private String endTime;

    @ApiModelProperty(value = "巡检人ids 前端忽略")
    private List<Long> userIds;
}

 ruoyi-system/src/main/java/com/ruoyi/system/service/AssetHouseInspectionRecordService.java

@@ -1,7 +1,11 @@
package com.ruoyi.system.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.system.model.AssetHouseInspectionRecord;
import com.ruoyi.system.query.AssetHouseInspectionRecordListQuery;
import com.ruoyi.system.vo.AssetHouseInspectionVO;
import com.ruoyi.system.vo.AssetRepairRequestVO;

/**
 * <p>
@@ -13,4 +17,5 @@
 */
public interface AssetHouseInspectionRecordService extends IService<AssetHouseInspectionRecord> {

    PageInfo<AssetHouseInspectionVO> pageList(AssetHouseInspectionRecordListQuery query);
}

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/AssetHouseInspectionRecordServiceImpl.java

@@ -1,10 +1,27 @@
package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.entity.TDept;
import com.ruoyi.system.mapper.AssetHouseInspectionDetailMapper;
import com.ruoyi.system.mapper.AssetHouseInspectionItemMapper;
import com.ruoyi.system.mapper.AssetHouseInspectionRecordMapper;
import com.ruoyi.system.model.AssetHouseInspectionDetail;
import com.ruoyi.system.model.AssetHouseInspectionItem;
import com.ruoyi.system.model.AssetHouseInspectionRecord;
import com.ruoyi.system.query.AssetHouseInspectionRecordListQuery;
import com.ruoyi.system.service.AssetHouseInspectionRecordService;
import com.ruoyi.system.vo.AssetHouseInspectionVO;
import com.ruoyi.system.vo.AssetRepairRequestVO;
import com.ruoyi.system.vo.system.ApprovalVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
@@ -17,4 +34,24 @@
@Service
public class AssetHouseInspectionRecordServiceImpl extends ServiceImpl<AssetHouseInspectionRecordMapper, AssetHouseInspectionRecord> implements AssetHouseInspectionRecordService {

    @Autowired
    private AssetHouseInspectionDetailMapper assetHouseInspectionDetailMapper;
    @Autowired
    private AssetHouseInspectionItemMapper assetHouseInspectionItemMapper;
    @Override
    public PageInfo<AssetHouseInspectionVO> pageList(AssetHouseInspectionRecordListQuery query) {
//        List<AssetHouseInspectionItem> assetHouseInspectionItems = assetHouseInspectionItemMapper.selectList(null);
        PageInfo<AssetHouseInspectionVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<AssetHouseInspectionVO> list = this.baseMapper.pageList(query,pageInfo);

//        List<Integer> inspectionIds = list.stream().map(AssetHouseInspectionRecord::getId).collect(Collectors.toList());
//        if (!inspectionIds.isEmpty()){
//            Map<Integer, List<AssetHouseInspectionDetail>> detailMaps = assetHouseInspectionDetailMapper.selectList(
//                    new LambdaQueryWrapper<AssetHouseInspectionDetail>()
//                            .in(AssetHouseInspectionDetail::getInspectionRecordId, inspectionIds)
//            ).stream().collect(Collectors.groupingBy(AssetHouseInspectionDetail::getInspectionRecordId));
//        }
        pageInfo.setRecords(list);
        return pageInfo;
    }
}

 ruoyi-system/src/main/java/com/ruoyi/system/vo/AssetHouseInspectionVO.java

New file
@@ -0,0 +1,18 @@
package com.ruoyi.system.vo;

import com.baomidou.mybatisplus.annotation.TableField;
import com.ruoyi.system.model.AssetHouseInspectionRecord;
import com.ruoyi.system.model.AssetRepairRequest;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

@Data
@ApiModel(value = "房屋巡检分页返回VO")
public class AssetHouseInspectionVO extends AssetHouseInspectionRecord {
    @ApiModelProperty(value = "房号")
    private String roomNumber;
    @ApiModelProperty(value = "巡检人名称")
    private String nickName;

}

 ruoyi-system/src/main/resources/mapper/system/AssetHouseInspectionRecordMapper.xml

@@ -25,5 +25,28 @@
    <sql id="Base_Column_List">
        id, asset_main_id, asset_code, asset_name, room_number, inspection_date, house_close_status, water_electronic_gas_close_status, inner_status, remarks, create_time, create_by, update_time, update_by, disabled
    </sql>
    <select id="pageList" resultType="com.ruoyi.system.vo.AssetHouseInspectionVO">
        select t1.*,t2.nick_name nickName,t3.room_number as roomNumber from asset_house_inspection_record t1
                    left join sys_user t2 on t1.inspection_id = t2.user_id
                                          left join asset_property_ext t3 on t1.asset_main_id = t3.asset_main_id
        where 1=1

        <if test="query.assetMainName != null and query.assetMainName != ''">
            AND (t1.asset_name like concat('%', #{query.assetMainName}, '%'))
        </if>
        <if test="query.userIds != null and query.userIds.size() > 0">
            AND t1.inspection_id IN
            <foreach item="item" index="index" collection="query.userIds" open="(" separator="," close=")">
                #{item}
            </foreach>
        </if>
        <if test="query.startTime != null and query.startTime != ''">
            AND t1.inspection_date >= #{query.startTime}
        </if>
        <if test="query.endTime != null and query.endTime != ''">
            AND t1.inspection_date &lt;= #{query.endTime}
        </if>
        AND t1.disabled = ${@com.ruoyi.common.enums.DisabledEnum@NO.getCode()}
    </select>

</mapper>