修改查看时间和删除关键词

guyue

2025-08-12 ff1fec7eae681e89e607fd441d2597ab67b5ed2a

 src/main/java/com/linghu/controller/PlatformController.java

@@ -18,6 +18,8 @@
import com.linghu.model.excel.PlatformExcel;
import com.linghu.model.excel.UserExcel;
import com.linghu.model.page.CustomPage;
import com.linghu.model.validator.CreateGroup;
import com.linghu.model.validator.UpdateGroup;
import com.linghu.service.PlatformService;
import com.linghu.service.TypeService;

@@ -35,6 +37,7 @@
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

@@ -57,60 +60,28 @@
    private PlatformService platformService;
    @Autowired
    private TypeService typeService;
    @Autowired
    private ReferenceMapper referenceMapper;
    @Autowired
    private KeywordMapper keywordMapper;

    @PostMapping
    @ApiOperation(value = "添加平台")
    public ResponseResult<Platform> add(@RequestBody Platform platform) {
        // 校验平台名称和域名不能为空
        if (!StringUtils.hasText(platform.getPlatform_name())) {
            return ResponseResult.error("平台名称不能为空");
        }
        if (!StringUtils.hasText(platform.getDomain())) {
            return ResponseResult.error("平台域名不能为空");
        }
        platform.setCreate_time(LocalDateTime.now());

        boolean success = platformService.save(platform);
        if (success) {
            return ResponseResult.success(platform);
        }
        return ResponseResult.error("添加平台失败");
    public ResponseResult<Platform> add( @Validated(CreateGroup.class) @RequestBody Platform platform) {
        return platformService.addPlatform(platform);
    }


    @DeleteMapping("/{platformId}")
    @ApiOperation(value = "删除平台")
    public ResponseResult<Void> delete(@PathVariable Integer platformId) {
        //平台被引用了没
        Integer count = Math.toIntExact(referenceMapper.selectCount(new LambdaQueryWrapper<Reference>().eq(Reference::getPlatform_id, platformId)));
        if (count > 0) {
            return ResponseResult.error("该平台被引用中，不能删除");
        }
        boolean success = platformService.removeById(platformId);
        if (success) {
            return ResponseResult.success();
        }
        return ResponseResult.error("删除平台失败");
    public ResponseResult<Void> delete( @PathVariable Integer platformId) {
        return platformService.deleteByPlatFormId(platformId);
    }



    @PutMapping
    @ApiOperation(value = "更新平台")
    public ResponseResult<Void> update(@RequestBody Platform platform) {
        // 校验平台名称和域名不能为空
        if (!StringUtils.hasText(platform.getPlatform_name())) {
            return ResponseResult.error("平台名称不能为空");
        }
        if (!StringUtils.hasText(platform.getDomain())) {
            return ResponseResult.error("平台域名不能为空");
        }

        platformService.updateById(platform);

        return ResponseResult.success();
    public ResponseResult<Void> update(@Validated(UpdateGroup.class) @RequestBody Platform platform) {
        return platformService.updatePlatform(platform);
    }


    @GetMapping("/{platformId}")
    @ApiOperation("根据id获取平台")
@@ -132,185 +103,23 @@
            @RequestParam(value = "questionId",required = false) Integer questionId,
            @RequestParam(value = "isNow",required = false) Integer isNow
            ) {
        List<Integer> platForm=new ArrayList<>();
        //先查找当前关键词下，所有的回答 的 所有的平台名称
        Keyword keyword=new Keyword();
        if (keywordId!=null){
             keyword = keywordMapper.selectById(keywordId);
        }

        if (keywordId != null && questionId == null) {

            List<Reference> references = referenceMapper.selectList(new LambdaQueryWrapper<Reference>()
                    .eq(Reference::getKeyword_id, keywordId)
                    .eq(Reference::getNum, isNow== 0 ? 1 : keyword.getNum())
            );
            platForm = references.stream().map(Reference::getPlatform_id).filter(Objects::nonNull).distinct().collect(Collectors.toList());
        }
        if (keywordId != null && questionId != null) {
            List<Reference> references = referenceMapper.selectList(new LambdaQueryWrapper<Reference>()
                    .eq(Reference::getKeyword_id, keywordId)
                    .eq(Reference::getNum, isNow== 0 ? 1 : keyword.getNum())
                    .eq(Reference::getQuestion_id, questionId)
            );
            platForm = references.stream().map(Reference::getPlatform_id).filter(Objects::nonNull).distinct().collect(Collectors.toList());
        }

        // 构建查询条件并添加排序（按创建时间倒序）
        LambdaQueryWrapper<Platform> queryWrapper = new LambdaQueryWrapper<>();
        if (!platForm.isEmpty()){
            queryWrapper.in(Platform::getPlatform_id, platForm);
        }else {
            if (page != null && pageSize != null){
                Page<Platform> pageInfo = new Page<>(page, pageSize);
                Page<Platform> result = platformService.page(pageInfo, queryWrapper);
                return ResponseResult.success(new CustomPage<>(result));
            }else {
                CustomPage<Platform> customPage = new CustomPage<>(new Page<>());
                customPage.setRecords(new ArrayList<>());
                customPage.setTotal(0);
                return ResponseResult.success(customPage);
            }

        }

        if (type_id != null) {
            queryWrapper.eq(Platform::getType_id, type_id);
        }
        queryWrapper.orderByDesc(Platform::getCreate_time); // 新增的排序条件
        if (page != null && pageSize != null) {
            Page<Platform> pageInfo = new Page<>(page, pageSize);
            Page<Platform> result = platformService.page(pageInfo, queryWrapper);
            return ResponseResult.success(new CustomPage<>(result));
        } else {
            List<Platform> list = platformService.list(queryWrapper);
            CustomPage<Platform> customPage = new CustomPage<>(new Page<>());
            customPage.setRecords(list);
            customPage.setTotal(list.size());
            return ResponseResult.success(customPage);
        }
        return platformService.platformPageList(page, pageSize, type_id, keywordId, questionId, isNow);
    }



    @GetMapping("/download")
    @ApiOperation("下载平台模板")
    public ResponseEntity<byte[]> downloadTemplate() throws IOException {
        // 获取所有类型名称
        List<Type> typeList = typeService.list();
        List<String> typeNames = typeList.stream()
                .map(Type::getType_name)
                .collect(Collectors.toList());

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        // 注册下拉框拦截器
        EasyExcel.write(out, PlatformExcel.class)
                .registerWriteHandler(new TypeDropdownWriteHandler(typeNames))
                .sheet("平台模板")
                .doWrite(new ArrayList<>());

        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=platform_template.xlsx")
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .body(out.toByteArray());
        return platformService.downloadPlatformExcel();
    }


    @PostMapping("/import")
    @ApiOperation("导入平台数据")
    public ResponseResult<String> importPlatforms(@RequestParam("file") MultipartFile file) {
        try {
            if (file.isEmpty()) {
                return ResponseResult.error("上传文件不能为空");
            }

            // 获取数据库中的旧数据
            List<Platform> oldPlatforms = platformService.list();

            // 使用自定义监听器读取数据（包含行号）
            PlatformExcelListener listener = new PlatformExcelListener();
            EasyExcel.read(file.getInputStream())
                    .head(PlatformExcel.class)
                    .sheet()
                    .registerReadListener(listener)
                    .doRead();

            List<ExcelDataWithRow<PlatformExcel>> excelList = listener.getDataList();
            List<Platform> platforms = new ArrayList<>();
            List<String> errorMessages = new ArrayList<>();

            // 遍历数据并验证
            for (ExcelDataWithRow<PlatformExcel> excelData : excelList) {
                int rowNum = excelData.getRowNumber();
                PlatformExcel excel = excelData.getData();
                List<String> rowErrors = new ArrayList<>();

                // 验证逻辑
                if (!StringUtils.hasText(excel.getPlatform_name())) {
                    rowErrors.add("平台名称不能为空");
                }
                if (!StringUtils.hasText(excel.getDomain())) {
                    rowErrors.add("平台域名不能为空");
                }

                // 查找类型（仅当类型名称不为空时检查，避免空指针）
                Integer typeId = null;
                if (StringUtils.hasText(excel.getType_name())) {
                    Type typeByName = typeService.getTypeByName(excel.getType_name());
                    if (typeByName == null) {
                        rowErrors.add("未知的平台类型: " + excel.getType_name());
                    } else {
                        typeId = typeByName.getType_id();
                    }
                } else {
                    rowErrors.add("平台类型不能为空");
                }

                if (!rowErrors.isEmpty()) {
                    errorMessages.add(String.format("第%d行错误: %s", rowNum, String.join("；", rowErrors)));
                } else {
                    // 构建Platform对象
                    Platform platform = new Platform();
                    platform.setPlatform_name(excel.getPlatform_name());
                    platform.setDomain(excel.getDomain());
                    platform.setType_id(typeId);
                    platform.setCreate_time(LocalDateTime.now());

                    // 检查重复性
                    boolean isDuplicate = false;
                    for (Platform oldPlatform : oldPlatforms) {
                        // 判断重复的条件，这里假设平台名称和域名都相同才算重复
                        if (oldPlatform.getPlatform_name().equals(platform.getPlatform_name()) &&
                                oldPlatform.getDomain().equals(platform.getDomain())) {
                            isDuplicate = true;
                            break;
                        }
                    }

                    // 如果不重复才添加到导入列表
                    if (!isDuplicate) {
                        platforms.add(platform);
                    }
                }
            }

            // 错误处理
            if (!errorMessages.isEmpty()) {
                StringBuilder errorMsg = new StringBuilder();
                errorMsg.append("导入失败，共").append(errorMessages.size()).append("条数据存在错误：\n");
                errorMessages.forEach(msg -> errorMsg.append(msg).append("\n"));
                return ResponseResult.error(400, errorMsg.toString());
            }

            // 无错误时导入
            if (!platforms.isEmpty()) {
                platformService.saveBatch(platforms);
                return ResponseResult.success("导入成功，新增" + platforms.size() + "条数据");
            } else {
                return ResponseResult.error("导入完成，没有新增数据（所有数据均已存在）");
            }

        } catch (Exception e) {
            log.error("文件解析失败", e);
            return ResponseResult.error("文件解析失败：" + e.getMessage());
        }
        return platformService.importPlatformsExcel(file);
    }


}