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.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.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

@Api(tags = "环境需求风险管理")
@RestController
@RequestMapping("/composite")
public class EnvironmentDemandRiskController {

    @Autowired
    private FactorDiscernService factorDiscernService;
    @Autowired
    private FactorControlService factorControlService;

    @Autowired
    private ExpectDiscrenService expectDiscrenService;
    @Autowired
    private ExpectEvaluateService evaluateService;

    @Autowired
    private RiskManageService riskManageService;
    @Autowired
    private RiskMonitorService riskMonitorService;


    /**
     * 内外部环境要素识别
     * @param factorDiscern
     * @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("/factor/discern/list")
    public CommonResult selectFactorDiscernList(FactorDiscern factorDiscern){
        return CommonResult.success(factorDiscernService.selectFactorDiscernList(factorDiscern));
    }

    @ApiOperation(value = "内外部环境要素识别")
    @GetMapping("/factor/discern/listAll")
    public CommonResult selectFactorDiscernListAll(FactorDiscern factorDiscern){
        return factorDiscernService.selectFactorDiscernListAll(factorDiscern);
    }

    /**
     * 内外部环境要素识别新增
     * @param factorDiscern
     * @return
     */
    @ApiOperation(value = "内外部环境要素识别新增")
    @PostMapping("/factor/discern/insert")
    public CommonResult insertFactorDiscern(@RequestBody FactorDiscern factorDiscern){
        return factorDiscernService.insertFactorDiscern(factorDiscern);
    }

    /**
     * 内外部环境要素识别修改
     * @param factorDiscern
     * @return
     */
    @ApiOperation(value = "内外部环境要素识别修改")
    @PostMapping("/factor/discern/update")
    public CommonResult updateFactorDiscern(@RequestBody FactorDiscern factorDiscern){
        return factorDiscernService.updateFactorDiscern(factorDiscern);
    }

    /**
     * 内外部环境要素识别删除
     * @param factorDiscrenId
     * @return
     */
    @ApiOperation(value = "内外部环境要素识别删除")
    @GetMapping("/factor/discern/deleted")
    public CommonResult deletedFactorDiscern(@RequestParam("factorDiscrenId") Integer factorDiscrenId){
        return factorDiscernService.deletedFactorDiscern(factorDiscrenId);
    }


    /**
     * 内外部环境要素控制
     * @param factorControl
     * @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("/factor/control/list")
    public CommonResult selectFactorControlList(FactorControl factorControl){
        return CommonResult.success(factorControlService.selectFactorControlList(factorControl));
    }

    /**
     * 内外部环境要素识别新增
     * @param factorControl
     * @return
     */
    @ApiOperation(value = "内外部环境要素控制新增")
    @PostMapping("/factor/control/insert")
    public CommonResult insertFactorControl(@RequestBody FactorControl factorControl){
        return factorControlService.insertFactorControl(factorControl);
    }

    /**
     * 内外部环境要素识别修改
     * @param factorControl
     * @return
     */
    @ApiOperation(value = "内外部环境要素控制修改")
    @PostMapping("/factor/control/update")
    public CommonResult updateFactorControl(@RequestBody FactorControl factorControl){
        return factorControlService.updateFactorControl(factorControl);
    }

    /**
     * 内外部环境要素识别删除
     * @param factorControlId
     * @return
     */
    @ApiOperation(value = "内外部环境要素控制删除")
    @GetMapping("/factor/control/deleted")
    public CommonResult deletedFactorControl(@RequestParam("factorControlId") Integer factorControlId){
        return factorControlService.deletedFactorControl(factorControlId);
    }

    /**
     * 相关方需求识别
     * @param expectDiscren
     * @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("/expect/discren/list")
    public CommonResult selectExpectDiscrenList(ExpectDiscren expectDiscren){
        return CommonResult.success(expectDiscrenService.selectExpectDiscrenList(expectDiscren));
    }
    @ApiOperation(value = "相关方需求识别")
    @GetMapping("/expect/discren/listAll")
    public CommonResult selectExpectDiscrenListAll(ExpectDiscren expectDiscren){
        return expectDiscrenService.selectExpectDiscrenListAll(expectDiscren);
    }


    /**
     * 相关方需求识别新增
     * @param expectDiscren
     * @return
     */
    @ApiOperation(value = "相关方需求识别新增")
    @PostMapping("/expect/discren/insert")
    public CommonResult insertFactorControl(@RequestBody ExpectDiscren expectDiscren){
        return expectDiscrenService.insertExpectDiscren(expectDiscren);
    }

    /**
     * 相关方需求识别修改
     * @param expectDiscren
     * @return
     */
    @ApiOperation(value = "相关方需求识别修改")
    @PostMapping("/expect/discren/update")
    public CommonResult updateExpectDiscren(@RequestBody ExpectDiscren expectDiscren){
        return expectDiscrenService.updateExpectDiscren(expectDiscren);
    }

    /**
     * 相关方需求识别删除
     * @param expectDiscrenId
     * @return
     */
    @ApiOperation(value = "相关方需求识别删除")
    @GetMapping("/expect/discren/deleted")
    public CommonResult deletedExpectDiscren(@RequestParam("expectDiscrenId") Integer expectDiscrenId){
        return expectDiscrenService.deletedExpectDiscren(expectDiscrenId);
    }

    /**
     * 相关方需求评价
     * @param expectEvaluate
     * @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("/expect/evaluate/list")
    public CommonResult selectExpectEvaluateList(ExpectEvaluate expectEvaluate){
        return CommonResult.success(evaluateService.selectExpectEvaluateList(expectEvaluate));
    }

    /**
     * 相关方需求识别新增
     * @param expectEvaluate
     * @return
     */
    @ApiOperation(value = "相关方需求评价新增")
    @PostMapping("/expect/evaluate/insert")
    public CommonResult insertExpectEvaluate(@RequestBody ExpectEvaluate expectEvaluate){
        return evaluateService.insertExpectEvaluate(expectEvaluate);
    }

    /**
     * 相关方需求识别修改
     * @param expectEvaluate
     * @return
     */
    @ApiOperation(value = "相关方需求评价修改")
    @PostMapping("/expect/evaluate/update")
    public CommonResult updateExpectEvaluate(@RequestBody ExpectEvaluate expectEvaluate){
        return evaluateService.updateExpectEvaluate(expectEvaluate);
    }

    /**
     * 相关方需求识别删除
     * @param expectEvaluateId
     * @return
     */
    @ApiOperation(value = "相关方需求评价删除")
    @GetMapping("/expect/evaluate/deleted")
    public CommonResult deletedExpectEvaluate(@RequestParam("expectEvaluateId") Integer expectEvaluateId){
        return evaluateService.deletedExpectEvaluate(expectEvaluateId);
    }



    /**
     * 风险管理控制
     * @param riskManage
     * @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("/risk/manage/list")
    public CommonResult selectRiskManageList(RiskManage riskManage){
        return CommonResult.success(riskManageService.selectRiskManageList(riskManage));
    }
    @ApiOperation(value = "风险管理控制")
    @GetMapping("/risk/manage/listAll")
    public CommonResult selectRiskManageListAll(RiskManage riskManage){
        return riskManageService.selectRiskManageListAll(riskManage);
    }


    /**
     * 风险管理控制新增
     * @param riskManage
     * @return
     */
    @ApiOperation(value = "风险管理控制新增")
    @PostMapping("/risk/manage/insert")
    public CommonResult insertRiskManage(@RequestBody RiskManage riskManage){
        return riskManageService.insertRiskManage(riskManage);
    }

    /**
     * 风险管理控制修改
     * @param riskManage
     * @return
     */
    @ApiOperation(value = "风险管理控制修改")
    @PostMapping("/risk/manage/update")
    public CommonResult updateRiskManage(@RequestBody RiskManage riskManage){
        return riskManageService.updateRiskManage(riskManage);
    }

    /**
     * 风险管理控制删除
     * @param riskManageId
     * @return
     */
    @ApiOperation(value = "风险管理控制删除")
    @GetMapping("/risk/manage/deleted")
    public CommonResult deletedRiskManage(@RequestParam("riskManageId") Integer riskManageId){
        return riskManageService.deletedRiskManage(riskManageId);
    }


    /**
     * 风险管理监视
     * @param riskMonitor
     * @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("/risk/monitor/list")
    public CommonResult selectRiskMonitorList(RiskMonitor riskMonitor){
        return CommonResult.success(riskMonitorService.selectRiskMonitorList(riskMonitor));
    }


    /**
     * 风险管理监视新增
     * @param riskMonitor
     * @return
     */
    @ApiOperation(value = "风险管理监视新增")
    @PostMapping("/risk/monitor/insert")
    public CommonResult insertRiskMonitor(@RequestBody RiskMonitor riskMonitor){
        return riskMonitorService.insertRiskMonitor(riskMonitor);
    }

    /**
     * 风险管理监视修改
     * @param riskMonitor
     * @return
     */
    @ApiOperation(value = "风险管理监视修改")
    @PostMapping("/risk/monitor/update")
    public CommonResult updateRiskMonitor(@RequestBody RiskMonitor riskMonitor){
        return riskMonitorService.updateRiskMonitor(riskMonitor);
    }

    /**
     * 风险管理监视删除
     * @param riskMonitorId
     * @return
     */
    @ApiOperation(value = "风险管理监视删除")
    @GetMapping("/risk/monitor/deleted")
    public CommonResult deletedRiskMonitor(@RequestParam("riskMonitorId") Integer riskMonitorId){
        return riskMonitorService.deletedRiskMonitor(riskMonitorId);
    }

}