package com.gkhy.exam.admin.controller.web;

import com.gkhy.exam.common.api.CommonResult;
import com.gkhy.exam.system.domain.*;
import com.gkhy.exam.system.domain.req.*;
import com.gkhy.exam.system.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@Api(tags = "企业质量目标管理")
@RestController
@RequestMapping("/quality-target")
public class QualityController {

    @Autowired
    private QualityService qualityService;

    @Autowired
    private QualityTargetService qualityTargetService;

    @Autowired
    private QualityAccomplishService qualityAccomplishService;

    @Autowired
    private QualityDecomposeService qualityDecomposeService;

    @Autowired
    private CatalogueService catalogueService;


    /**
     * 质量目标列表
     * @param quality
     * @return
     */
    @ApiOperation(value = "质量目标列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/policy/list")
    public CommonResult listQuality(Quality quality){
        return CommonResult.success(qualityService.selectQualityList(quality));
    }

    @GetMapping("/policy/listAll")
    public CommonResult listQualityAll(Quality quality){
        return CommonResult.success(qualityService.selectQualityListAll(quality));
    }

    /**
     * 质量目标新增
     * @param qualityTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标新增")
    @PostMapping("/policy/insert")
    public CommonResult insertQuality(@RequestBody QualityTargetReq qualityTargetReq){
        return qualityService.insertQuality(qualityTargetReq);
    }

    /**
     * 质量目标修改
     * @param qualityTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标修改")
    @PostMapping("/policy/update")
    public CommonResult updateQuality(@RequestBody QualityTargetReq qualityTargetReq){
        return qualityService.updateQuality(qualityTargetReq);
    }

    /**
     * 质量目标删除
     * @param qualityId
     * @return
     */
    @ApiOperation(value = "质量目标删除")
    @GetMapping("/policy/deleted")
    public CommonResult deletedQuality(@RequestParam("qualityId") Integer qualityId){
        return qualityService.deletedQuality(qualityId);
    }

    /**
     * 质量目标分解列表
     * @param qualityReq
     * @return
     */
    @ApiOperation(value = "质量目标分解列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/decompose/list")
    public CommonResult listQualityDecompose(QualityReq qualityReq){
        return CommonResult.success(qualityDecomposeService.selectQualityDecomposeList(qualityReq));
    }

    /**
     * 质量目标分解新增
     * @param decomposeTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标分解新增")
    @PostMapping("/decompose/insert")
    public CommonResult insertQualityDecompose(@RequestBody DecomposeTargetReq decomposeTargetReq){
        return qualityDecomposeService.insertQualityDecompose(decomposeTargetReq);
    }

    /**
     * 质量目标分解修改
     * @param decomposeTargetReq
     * @return
     */
    @ApiOperation(value = "质量目标分解修改")
    @PostMapping("/decompose/update")
    public CommonResult updateQualityDecompose(@RequestBody DecomposeTargetReq decomposeTargetReq){
        return qualityDecomposeService.updateQualityDecompose(decomposeTargetReq);
    }

    /**
     * 质量目标分解删除
     * @param decomposeId
     * @return
     */
    @ApiOperation(value = "质量目标分解删除")
    @GetMapping("/decompose/deleted")
    public CommonResult deletedQualityDecompose(@RequestParam("qualityDecomposeId") Integer decomposeId){
        return qualityDecomposeService.deletedQualityDecompose(decomposeId);
    }


    /**
     * 质量目标完成情况列表
     * @param qualityReq
     * @return
     */
    @ApiOperation(value = "质量目标完成情况列表(分页)")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType = "query", name = "pageNum", dataType = "int", required = false, value = "当前页,默认1"),
            @ApiImplicitParam(paramType = "query", name = "pageSize", dataType = "int", required = false, value = "每页数目,默认10"),
    })
    @GetMapping("/accomplish/list")
    public CommonResult listQualityAccomplish(QualityReq qualityReq){
        return CommonResult.success(qualityAccomplishService.selectQualityAccomplishList(qualityReq));
    }

    /**
     * 质量目标完成情况新增
     * @param qualityAccomplish
     * @return
     */
    @ApiOperation(value = "质量目标完成情况新增")
    @PostMapping("/accomplish/insert")
    public CommonResult insertQualityAccomplish(@RequestBody QualityAccomplish qualityAccomplish){
        return qualityAccomplishService.insertQualityAccomplish(qualityAccomplish);
    }

    /**
     * 质量目标完成情况修改
     * @param qualityAccomplish
     * @return
     */
    @ApiOperation(value = "质量目标完成情况修改")
    @PostMapping("/accomplish/update")
    public CommonResult updateQualityAccomplish(@RequestBody QualityAccomplish qualityAccomplish){
        return qualityAccomplishService.updateQualityAccomplish(qualityAccomplish);
    }

    /**
     * 质量目标完成情况删除
     * @param qualityAccomplishId
     * @return
     */
    @ApiOperation(value = "质量目标完成情况删除")
    @GetMapping("/accomplish/deleted")
    public CommonResult deletedQualityAccomplish(@RequestParam("qualityAccomplishId") Integer qualityAccomplishId){
        return qualityAccomplishService.deletedQualityAccomplish(qualityAccomplishId);
    }

    /**
     * 质量目标对应数据
     * @param qualityId
     * @return
     */
    @ApiOperation(value = "质量目标对应数据")
    @GetMapping("/target/list")
    public CommonResult selectTargetList(@RequestParam("qualityId") Integer qualityId){
        return qualityTargetService.selectTargetList(qualityId);
    }


    /**
     * 质量管理体系运行列表
     * @param catalogueReq
     * @return
     */
    @ApiOperation(value = "质量管理体系运行列表")
    @GetMapping("/catalogue/list")
    public CommonResult listCatalogue(CatalogueReq catalogueReq){
        return CommonResult.success(catalogueService.selectCatalogueList(catalogueReq));
    }


    /**
     * 质量管理体系运行新增
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "质量管理体系运行新增")
    @PostMapping("/catalogue/insert")
    public CommonResult insertCatalogue(@RequestBody Catalogue catalogue){
        return catalogueService.insertCatalogue(catalogue);
    }

    /**
     * 质量管理体系运行修改
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "质量管理体系运行修改")
    @PostMapping("/catalogue/update")
    public CommonResult updateCatalogue(@RequestBody Catalogue catalogue){
        return catalogueService.updateCatalogue(catalogue);
    }

    /**
     * 质量管理体系运行删除
     * @param catalogueId
     * @return
     */
    @ApiOperation(value = "质量管理体系运行删除")
    @GetMapping("/catalogue/deleted")
    public CommonResult deletedCatalogue(@RequestParam("catalogueId") Integer catalogueId){
        return catalogueService.deletedCatalogue(catalogueId);
    }



    /**
     * 目录数据列表
     * @param catalogueReq
     * @return
     */
    @ApiOperation(value = "目录数据列表")
    @GetMapping("/catalogueData/list")
    public CommonResult listCatalogueData(CatalogueReq catalogueReq){
        return CommonResult.success(catalogueService.selectCatalogueDataList(catalogueReq));
    }


    /**
     * 目录数据新增
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "目录数据新增")
    @PostMapping("/catalogueData/insert")
    public CommonResult insertCatalogueData(@RequestBody CatalogueDataReq catalogue){
        return catalogueService.insertCatalogueData(catalogue);
    }

    /**
     * 目录数据修改
     * @param catalogue
     * @return
     */
    @ApiOperation(value = "目录数据修改")
    @PostMapping("/catalogueData/update")
    public CommonResult updateCatalogueData(@RequestBody CatalogueDataReq catalogue){
        return catalogueService.updateCatalogueData(catalogue);
    }

    /**
     * 目录数据删除
     * @param catalogueDataId
     * @return
     */
    @ApiOperation(value = "目录数据删除")
    @GetMapping("/catalogueData/deleted")
    public CommonResult deletedCatalogueData(@RequestParam("catalogueDataId") Integer catalogueDataId){
        return catalogueService.deletedCatalogueData(catalogueDataId);
    }

    /**
     * 目录数据文件列表
     * @param catalogueReq
     * @return
     */
    @ApiOperation(value = "目录数据文件列表")
    @GetMapping("/catalogueDataFile/list")
    public CommonResult listCatalogueDataFile(CatalogueReq catalogueReq){
        return CommonResult.success(catalogueService.selectCatalogueDataFileList(catalogueReq));
    }


    /**
     * 目录数据文件新增
     * @param catalogueDataFile
     * @return
     */
    @ApiOperation(value = "目录数据文件新增")
    @PostMapping("/catalogueDataFile/insert")
    public CommonResult insertCatalogueDataFile(@RequestBody CatalogueDataFile catalogueDataFile){
        return catalogueService.insertCatalogueDataFile(catalogueDataFile);
    }

    /**
     * 目录数据文件修改
     * @param catalogueDataFile
     * @return
     */
    @ApiOperation(value = "目录数据文件修改")
    @PostMapping("/catalogueDataFile/update")
    public CommonResult updateCatalogueDataFile(@RequestBody CatalogueDataFile catalogueDataFile){
        return catalogueService.updateCatalogueDataFile(catalogueDataFile);
    }

    /**
     * 目录数据文件删除
     * @param dataFileId
     * @return
     */
    @ApiOperation(value = "目录数据文件删除")
    @GetMapping("/catalogueDataFile/deleted")
    public CommonResult deletedCatalogueDataFile(@RequestParam("dataFileId") Integer dataFileId){
        return catalogueService.deletedCatalogueDataFile(dataFileId);
    }



}