PAS/src/main/java/cn/cslg/pas/controller/NoveltyProjectController.java

package cn.cslg.pas.controller;

import cn.cslg.pas.common.core.base.Constants;
import cn.cslg.pas.common.dto.*;
import cn.cslg.pas.common.dto.NoveltyProjectDTO.NoveltyProjectCopyDTO;
import cn.cslg.pas.common.dto.NoveltyProjectDTO.NoveltyRetrieveRecordDTO;
import cn.cslg.pas.common.dto.NoveltyProjectDTO.QueryTemplateDTO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.utils.Response;
import cn.cslg.pas.common.vo.NoveltyProjectVO.QueryTemplateVO;
import cn.cslg.pas.common.vo.QueryCompareFileVO;
import cn.cslg.pas.common.vo.QueryInventionPointVO;
import cn.cslg.pas.common.vo.TechnicalCaseVO;
import cn.cslg.pas.service.business.NoveltyProjectService;
import cn.cslg.pas.service.business.TechnicalCaseService;
import cn.cslg.pas.service.novelty.NoveltyReportTemplateService;
import cn.cslg.pas.service.novelty.NoveltySearchRecordService;
import cn.cslg.pas.service.novelty.NoveltyCompareLiteratureService;
import io.swagger.v3.oas.annotations.Operation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

import java.io.IOException;

@RequestMapping(Constants.API_XiaoSHI + "/noveltyProject")
@RestController
public class NoveltyProjectController {

    @Autowired
    private NoveltyProjectService noveltyProjectService;

    @Autowired
    private TechnicalCaseService technicalCaseService;

    @Autowired
    private NoveltyReportTemplateService noveltyReportTemplateService;

    @Autowired
    private NoveltySearchRecordService noveltySearchRecordService;

    @Autowired
    private NoveltyCompareLiteratureService noveltyCompareLiteratureService;

    @Operation(summary = "添加查新检索报告")
    @PostMapping("/addNoveltyProject")
    public Response addNoveltyProject(@RequestBody AddNoveltyProjectDTO noveltyProjectDTO) throws Exception {
        Integer noveltyProjectId = null;
        try {
            noveltyProjectId = noveltyProjectService.addNoveltyProject(noveltyProjectDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(noveltyProjectId);
    }

    @Operation(summary = "查询查新检索报告")
    @PostMapping("/queryNoveltyProject")
    public Response queryNoveltyProject(@RequestBody QueryNoveltyProjectDTO noveltyProjectDTO) throws Exception {
        Records records = new Records();
        try {
            records = noveltyProjectService.queryNoveltyProject(noveltyProjectDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(records);
    }

    @Operation(summary = "编辑查新检索报告")
    @PostMapping("/updateNoveltyProject")
    public Response updateNoveltyProject(@RequestBody AddNoveltyProjectDTO noveltyProjectDTO) throws Exception {
        Integer noveltyProjectId = null;
        try {
            noveltyProjectId = noveltyProjectService.updateNoveltyProject(noveltyProjectDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(noveltyProjectId);
    }

    @Operation(summary = "删除查新检索报告")
    @PostMapping("/deleteNoveltyProject")
    public Response deleteNoveltyProject(@RequestBody NoveltyProjectIdDTO vo) throws Exception {
        try {
            noveltyProjectService.deleteNoveltyProject(vo);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success("删除成功");
    }

    @Operation(summary = "添加或更新技术方案信息")
    @PostMapping("/addOrUpdateTechnicalCase")
    public Response addOrUpdateTechnicalCase(@RequestBody AddTechnicalCaseDTO caseDTO) throws Exception {
        TechnicalCaseIdDTO caseIdDTO = new TechnicalCaseIdDTO();
        try {
            caseIdDTO = technicalCaseService.addOrUpdateTechnicalCase(caseDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(caseIdDTO);
    }

    @Operation(summary = "查询技术方案信息")
    @PostMapping("/queryTechnicalCase")
    public Response queryTechnicalCase(@RequestBody TechnicalCaseIdDTO caseIdDTO) throws Exception {
        TechnicalCaseVO caseVO = new TechnicalCaseVO();
        try {
            caseVO = technicalCaseService.queryTechnicalCase(caseIdDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(caseVO);
    }

    @Operation(summary = "查询技术方案相似发明点")
    @PostMapping("/querySimilarInventionPoint")
    public Response querySimilarInventionPoint(@RequestBody String content) throws Exception {
        List<QueryInventionPointVO> inventionPointVOS = new ArrayList<>();
        try {
            inventionPointVOS = technicalCaseService.querySimilarInventionPoint(content);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(inventionPointVOS);
    }

    @Operation(summary = "更新对比文件")
    @PostMapping("/editCompareFile")
    public Response editCompareFile(@RequestBody AddCompareFileDTO fileDTO) throws Exception {
        Integer compareFileId = null;
        try {
            compareFileId = noveltyCompareLiteratureService.editCompareFile(fileDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(compareFileId);
    }

    @Operation(summary = "查询查新报告对比专利详情")
    @PostMapping("/queryCompareFile")
    public Response queryCompareFile(@RequestBody QueryCompareFileDTO fileDTO) throws Exception {
        List<QueryCompareFileVO> queryCompareFileVOS = new ArrayList<>();
        try {
            queryCompareFileVOS = noveltyCompareLiteratureService.queryCompareFile(fileDTO);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success(queryCompareFileVOS);
    }

    @Operation(summary = "删除对比文件")
    @PostMapping("/delCompareFile")
    public Response delCompareFile(@RequestBody CompareFileIdDTO vo) throws Exception {
        try {
            noveltyCompareLiteratureService.delCompareFile(vo);
        } catch (Exception e) {
            return Response.error(e.getMessage());
        }
        return Response.success("删除成功");
    }

    @Operation(summary = "查询查新检索报告模板")
    @PostMapping("/queryTemplate")
    public Response queryTemplate(@RequestBody QueryTemplateDTO queryTemplateDTO) throws IOException {
         Records records = noveltyReportTemplateService.queryTemplate(queryTemplateDTO);
        return Response.success(records);
    }

    @Operation(summary = "查询检索记录")
    @PostMapping("/querySearchRecord")
    public Response querySearchRecord(@RequestBody QuerySearchRecordDTO querySearchRecordDTO) throws IOException {
        Records records = noveltySearchRecordService.querySearchRecord(querySearchRecordDTO);
        return Response.success(records);
    }

    @Operation(summary = "添加检索记录")
    @PostMapping("/addSearchRecord")
    public Response addSearchRecord(@RequestBody NoveltyRetrieveRecordDTO noveltyRetrieveRecordDTO){
        Integer id = noveltySearchRecordService.addSearchRecord(noveltyRetrieveRecordDTO);
        Records records = new Records();
        records.setData(id);
        return Response.success(records);
    }

    @Operation(summary = "修改检索记录")
    @PostMapping("/updateSearchRecord")
    public Response updateSearchRecord(@RequestBody NoveltyRetrieveRecordDTO noveltyRetrieveRecordDTO){
        Integer id = noveltySearchRecordService.updateSearchRecord(noveltyRetrieveRecordDTO);
        Records records = new Records();
        records.setData(id);
        return Response.success(records);
    }

    @Operation(summary = "删除检索记录")
    @PostMapping("/deleteSearchRecord")
    public Response deleteSearchRecord(@RequestBody List<Integer> retrieveIds){
        List<Integer> ids = noveltySearchRecordService.deleteSearchRecord(retrieveIds);
        Records records = new Records();
        records.setData(ids);
        return Response.success(records);
    }
    @Operation(summary = "复用报告")
    @PostMapping("/copyMessage")
    public Response copyMessage(@RequestBody NoveltyProjectCopyDTO noveltyProjectCopyDTO) throws Exception{
         noveltyProjectService.copyNoveltyProject(noveltyProjectCopyDTO);
        return Response.success(true);
    }

}