data-analysis/server/src/main/java/edp/davinci/controller/QualityTaskController.java

package edp.davinci.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import edp.core.annotation.CurrentUser;
import edp.core.exception.ServerException;
import edp.davinci.common.controller.BaseController;
import edp.davinci.core.common.Constants;
import edp.davinci.core.common.ResultMap;
import edp.davinci.core.enums.CronJobStatusEnum;
import edp.davinci.dto.cronJobDto.CronJobBaseInfo;
import edp.davinci.dto.cronJobDto.CronJobInfo;
import edp.davinci.dto.qualityAuditor.QualityAuditorDto;
import edp.davinci.dto.qualityAuditor.QualityTaskDto;
import edp.davinci.dto.sourceDto.SourceDetail;
import edp.davinci.dto.viewDto.ViewBaseInfo;
import edp.davinci.model.CronJob;
import edp.davinci.model.QualityAuditor;
import edp.davinci.model.QualityTask;
import edp.davinci.model.User;
import edp.davinci.service.*;
import io.jsonwebtoken.lang.Collections;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

@Api(value = "/qualityTask", tags = "qualityTask", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
@ApiResponses(@ApiResponse(code = 404, message = "qualityTask not found"))
@Slf4j
@RestController
@RequestMapping(value = Constants.BASE_API_PATH + "/qualityTask", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public class QualityTaskController extends BaseController {
    @Autowired
    private QualityTaskService qualityTaskService;

    @Autowired
    private QualityAuditorService qualityAuditorService;

    @Autowired
    private CronJobService cronJobService;

    @Autowired
    private ViewService viewService;

    @Autowired
    private SourceService sourceService;

    /**
     * 获取 质量任务
     *
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "get qualityTask")
    @GetMapping(value = "/getQualityTask")
    public ResponseEntity getQualityTask(@ApiIgnore @CurrentUser User user,
                                         HttpServletRequest request) {

        List<QualityTask> qualityTasks = qualityTaskService.getQualityTask();
        dualQualityTasks(qualityTasks);
        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payloads(qualityTasks));
    }

    /**
     * 获取 质量任务
     *
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "get qualityTask")
    @GetMapping(value = "/getQualityTaskByPid")
    public ResponseEntity getQualityTask(@ApiIgnore @CurrentUser User user,
                                         @RequestParam(required = false) Long pId,
                                         HttpServletRequest request) {

        List<QualityTask> qualityTasks = qualityTaskService.getQualityTaskByPid(pId);
        dualQualityTasks(qualityTasks);
        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payloads(qualityTasks));
    }

    private void dualQualityTasks(List<QualityTask> qualityTasks) {
        if (!Collections.isEmpty(qualityTasks)) {
            for (QualityTask qualityTask : qualityTasks) {
                if (!StringUtils.isEmpty(qualityTask.getMetadataConfig())) {
                    JSONArray jsonArray = JSONArray.parseArray(qualityTask.getMetadataConfig());
                    qualityTask.setAuditorCount(jsonArray.size());
                }
            }
        }
    }

    /**
     * 增加 质量任务
     *
     * @param qualityTask
     * @param bindingResult
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "create qualityTask")
    @PostMapping(value = "/createQualityTask", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity createQualityTask(@Valid @RequestBody QualityTask qualityTask,
                                            @ApiIgnore BindingResult bindingResult,
                                            @ApiIgnore @CurrentUser User user,
                                            HttpServletRequest request) {

        if (bindingResult.hasErrors()) {
            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message(bindingResult.getFieldErrors().get(0).getDefaultMessage());
            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
        }

        qualityTask = qualityTaskService.createQualityTask(qualityTask);

        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payload(qualityTask));
    }

    /**
     * 修改 qualityTask
     *
     * @param id
     * @param qualityTask
     * @param bindingResult
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "update qualityTask")
    @PutMapping(value = "/updateQualityTask/{id}", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity updateQualityTask(@PathVariable Long id,
                                            @Valid @RequestBody QualityTask qualityTask,
                                            @ApiIgnore BindingResult bindingResult,
                                            @ApiIgnore @CurrentUser User user,
                                            HttpServletRequest request) {


        if (invalidId(id) || !id.equals(qualityTask.getId())) {
            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message("Invalid dataSubject id");
            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
        }

        if (bindingResult.hasErrors()) {
            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message(bindingResult.getFieldErrors().get(0).getDefaultMessage());
            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
        }

        qualityTaskService.updateQualityTask(qualityTask);
        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request));
    }


    /**
     * 删除 qualityTask
     *
     * @param id
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "delete qualityTask")
    @DeleteMapping("/deleteQualityTask/{id}")
    public ResponseEntity deleteQualityTask(@PathVariable Long id,
                                            @ApiIgnore @CurrentUser User user,
                                            HttpServletRequest request) {
        if (invalidId(id)) {
            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message("Invalid dataSubject id");
            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
        }

        QualityTask qualityTask =  qualityTaskService.getQualityTask(id);
        qualityTaskService.deleteQualityTask(id);
        cronJobService.stopCronJob(qualityTask.getCronJobId(),user);
        cronJobService.deleteCronJob(qualityTask.getCronJobId(),user);
        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request));
    }


    /**
     * 立即稽核
     *
     * @param id
     * @param request
     * @return
     */
    @ApiOperation(value = "auditor")
    @GetMapping(value = "/auditor/{id}")
    public ResponseEntity auditor(@PathVariable Long id, HttpServletRequest request) {
        // 执行任务
        qualityTaskService.auditor(id);
        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request));
    }

    /**
     * 设置调度
     *
     * @param cronJob
     * @param request
     * @return
     */
    @ApiOperation(value = "setDispatch")
    @PutMapping(value = "/setDispatch/{id}", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity setDispatch(@PathVariable Long id, @RequestBody CronJobInfo cronJob, @ApiIgnore BindingResult bindingResult, @ApiIgnore @CurrentUser User user, HttpServletRequest request) {

        // 1. 保存任务
        if (bindingResult.hasErrors()) {
            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message(bindingResult.getFieldErrors().get(0).getDefaultMessage());
            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
        }

        QualityTask qualityTask = qualityTaskService.getQualityTask(id);

        // 2. 判断任务状态
        if (null != qualityTask) {
            if (!StringUtils.isEmpty(qualityTask.getCronJobId())) {
                CronJob cronJob1 = cronJobService.getCronJob(qualityTask.getCronJobId(), user);
                if (null != cronJob1) {
                    // 停止
                    cronJobService.stopCronJob(cronJob1.getId(), user);
                    // 删掉任务
                    cronJobService.deleteCronJob(cronJob1.getId(), user);
                }

            }
        }

        // 3. 创建任务
        cronJob.setName("质量稽核任务-"+ new Random().nextInt());
        cronJob.setConfig("{}");
        cronJob.setDescription("质量稽核任务");
        CronJobInfo jobInfo = cronJobService.createCronJob(cronJob, user);

        // 4. 执行
        try {
            CronJob cronJobStart =  cronJobService.startCronJob(jobInfo.getId(), user);
        }catch (Exception e)
        {
            log.info("定时任务启动失败"+ jobInfo.getCronExpression());
            cronJobService.deleteCronJob(jobInfo.getId(),user);
            throw new ServerException("定时任务启动失败"+ jobInfo.getCronExpression());
        }

        // 5.  更新定时规则id到任务中
        qualityTask.setCronJobId(jobInfo.getId());
        qualityTaskService.updateQualityTask(qualityTask);


        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request));
    }

    /**
     * 获取调度
     *
     * @param
     * @param request
     * @return
     */
    @ApiOperation(value = "getDispatch")
    @GetMapping(value = "/getDispatch/{id}", consumes = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity getDispatch(@PathVariable Long id, @ApiIgnore @CurrentUser User user, HttpServletRequest request) {

//        if (bindingResult.hasErrors()) {
//            ResultMap resultMap = new ResultMap(tokenUtils).failAndRefreshToken(request).message(bindingResult.getFieldErrors().get(0).getDefaultMessage());
//            return ResponseEntity.status(resultMap.getCode()).body(resultMap);
//        }

        QualityTask qualityTask = qualityTaskService.getQualityTask(id);
        CronJob cronJob = null;
        if (null != qualityTask) {
            cronJob = cronJobService.getCronJob(qualityTask.getCronJobId(),user);
        }

        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payload(cronJob));
    }

    /**
     * 质量报告
     *
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "get qualityReport")
    @GetMapping(value = "/qualityReport")
    public ResponseEntity qualityReport(@RequestParam(value = "systemId", required = true) Long systemId, @RequestParam(value = "starTime", required = true) String starTime, @RequestParam(value = "endTime", required = true) String endTime, @ApiIgnore @CurrentUser User user,
                                        HttpServletRequest request) {

        // 查询
        List<QualityTaskDto> qualityTasks = qualityTaskService.getQualityTaskListCondition(systemId, null);

        List<QualityTaskDto> resultTask = new ArrayList<>();

        for (QualityTaskDto qualityTaskDto : qualityTasks) {

            List<QualityAuditor> qualityAuditorList = qualityAuditorService.getQualityAuditorListByTaskId(qualityTaskDto.getId(), starTime, endTime);

            if (null == qualityAuditorList || qualityAuditorList.size() == 0) {
                continue;
            }

            DecimalFormat df = new DecimalFormat("0.00");//格式化小数

            // 完整性
            double averagingIntegrityCorrect = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getIntegrityCorrect));
            double averagingIntegrityError = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getIntegrityError));
            qualityTaskDto.setIntegrityCorrect(averagingIntegrityCorrect);
            qualityTaskDto.setIntegrityError(averagingIntegrityError);
            if ((averagingIntegrityCorrect + averagingIntegrityError) == 0) {
                qualityTaskDto.setIntegrityCorrectProbability("0%");
                qualityTaskDto.setIntegrityErrorProbability("0%");
            } else {
                qualityTaskDto.setIntegrityCorrectProbability(df.format((float) averagingIntegrityCorrect / (averagingIntegrityCorrect + averagingIntegrityError) * 100 )+ "%");
                qualityTaskDto.setIntegrityErrorProbability(df.format((float) averagingIntegrityError / (averagingIntegrityCorrect + averagingIntegrityError)* 100 )+ "%");
            }
            // 一致性

            double averagingUniformityCorrect = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getUniformityCorrect));
            double averagingUniformityError = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getUniformityError));
            qualityTaskDto.setUniformityCorrect(averagingUniformityCorrect);
            qualityTaskDto.setUniformityError(averagingUniformityError);
            if ((averagingUniformityCorrect + averagingUniformityError) == 0) {
                qualityTaskDto.setUniformityCorrectProbability("0%");
                qualityTaskDto.setUniformityErrorProbability("0%");
            } else {
                qualityTaskDto.setUniformityCorrectProbability(df.format((float) averagingUniformityCorrect / (averagingUniformityCorrect + averagingUniformityError)* 100 )+ "%");
                qualityTaskDto.setUniformityErrorProbability(df.format((float) averagingUniformityError / (averagingUniformityCorrect + averagingUniformityError)* 100 )+ "%");
            }
            // 规范性
            double averagingNormativeCorrect = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getNormativeCorrect));
            double averagingNormativeError = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getNormativeError));
            qualityTaskDto.setNormativeCorrect(averagingNormativeCorrect);
            qualityTaskDto.setNormativeError(averagingNormativeError);
            if ((averagingNormativeCorrect + averagingNormativeError) == 0) {
                qualityTaskDto.setNormativeCorrectProbability("0%");
                qualityTaskDto.setNormativeErrorProbability("0%");
            } else {
                qualityTaskDto.setNormativeCorrectProbability(df.format((float) averagingNormativeCorrect / (averagingNormativeCorrect + averagingNormativeError)* 100 )+ "%");
                qualityTaskDto.setNormativeErrorProbability(df.format((float) averagingNormativeError / (averagingNormativeCorrect + averagingNormativeError)* 100 )+ "%");
            }
            // 准确定
            double averagingAccuracyCorrect = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getAccuracyCorrect));
            double averagingAccuracyError = qualityAuditorList.stream().collect(Collectors.averagingInt(QualityAuditor::getAccuracyError));
            qualityTaskDto.setAccuracyCorrect(averagingAccuracyCorrect);
            qualityTaskDto.setAccuracyError(averagingAccuracyError);
            if ((averagingAccuracyCorrect + averagingAccuracyError) == 0) {
                qualityTaskDto.setAccuracyCorrectProbability("0%");
                qualityTaskDto.setAccuracyErrorProbability("0%");
            } else {
                qualityTaskDto.setAccuracyCorrectProbability(df.format((float) averagingAccuracyCorrect / (averagingAccuracyCorrect + averagingAccuracyError)* 100 )+ "%");
                qualityTaskDto.setAccuracyErrorProbability(df.format((float) averagingAccuracyError / (averagingAccuracyCorrect + averagingAccuracyError)* 100 )+ "%");
            }

            resultTask.add(qualityTaskDto);
        }

        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payloads(resultTask));
    }

    /**
     * 质量报告详情
     *
     * @param user
     * @param request
     * @return
     */
    @ApiOperation(value = "get qualityReportDetail")
    @GetMapping(value = "/qualityReportDetail/{id}")
    public ResponseEntity qualityReportDetail(@PathVariable Long id,
                                              @ApiIgnore @CurrentUser User user,
                                              @RequestParam(value = "startTime", required = true) String startTime,
                                              @RequestParam(value = "endTime", required = true) String endTime,
                                              HttpServletRequest request) {
        List<QualityAuditorDto> qualityAuditorDtoList = new ArrayList<QualityAuditorDto>();

        List<QualityAuditor> qualityAuditors = qualityAuditorService.getQualityAuditorListByTaskId(id, startTime, endTime);

        for (QualityAuditor qualityAuditor : qualityAuditors) {
            QualityAuditorDto qualityAuditorDto = new QualityAuditorDto();
            qualityAuditorDto.setAuditorTime(qualityAuditor.getAuditorTime());
            BeanUtils.copyProperties(qualityAuditor, qualityAuditorDto);
            DecimalFormat df = new DecimalFormat("0.00");//格式化小数

            if (null != qualityAuditor.getIntegrityCorrect() && null != qualityAuditor.getIntegrityError()) {
                if ((qualityAuditor.getIntegrityCorrect() + qualityAuditor.getIntegrityCorrect()) == 0) {
                    qualityAuditorDto.setIntegrityCorrectProbability("0%");
                    qualityAuditorDto.setIntegrityErrorProbability("0%");
                } else {
                    // 完整性
                    String integrityCorrectProbability = df.format((float) qualityAuditor.getIntegrityCorrect() / (qualityAuditor.getIntegrityCorrect() + qualityAuditor.getIntegrityError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setIntegrityCorrectProbability(integrityCorrectProbability);
                    String integrityErrorProbability = df.format((float) qualityAuditor.getIntegrityError() / (qualityAuditor.getIntegrityCorrect() + qualityAuditor.getIntegrityError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setIntegrityErrorProbability(integrityErrorProbability);
                }
            }

            if (null != qualityAuditor.getUniformityCorrect() && null != qualityAuditor.getUniformityError()) {
                if ((qualityAuditor.getUniformityCorrect() + qualityAuditor.getUniformityError()) == 0) {
                    qualityAuditorDto.setUniformityCorrectProbability("0%");
                    qualityAuditorDto.setUniformityErrorProbability("0%");
                } else {
                    // 一致性
                    String uniformityCorrectProbability = df.format((float) qualityAuditor.getUniformityCorrect() / (qualityAuditor.getUniformityCorrect() + qualityAuditor.getUniformityError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setUniformityCorrectProbability(uniformityCorrectProbability);
                    String uniformityErrorProbability = df.format((float) qualityAuditor.getUniformityError() / (qualityAuditor.getUniformityCorrect() + qualityAuditor.getUniformityError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setUniformityErrorProbability(uniformityErrorProbability);
                }
            }

            if (null != qualityAuditor.getNormativeCorrect() && null != qualityAuditor.getNormativeError()) {
                if ((qualityAuditor.getNormativeCorrect() + qualityAuditor.getNormativeError()) == 0) {
                    qualityAuditorDto.setNormativeCorrectProbability("0%");
                    qualityAuditorDto.setNormativeErrorProbability("0%");
                } else {
                    // 规范性
                    String normativeCorrectProbability = df.format((float) qualityAuditor.getNormativeCorrect() / (qualityAuditor.getNormativeCorrect() + qualityAuditor.getNormativeError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setNormativeCorrectProbability(normativeCorrectProbability);
                    String normativeErrorProbability = df.format((float) qualityAuditor.getNormativeError() / (qualityAuditor.getNormativeCorrect() + qualityAuditor.getNormativeError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setNormativeErrorProbability(normativeErrorProbability);
                }
            }
            if (null != qualityAuditor.getAccuracyCorrect() && null != qualityAuditor.getAccuracyError()) {
                if ((qualityAuditor.getAccuracyCorrect() + qualityAuditor.getAccuracyError()) == 0) {
                    qualityAuditorDto.setAccuracyCorrectProbability("0%");
                    qualityAuditorDto.setAccuracyErrorProbability("0%");
                } else {
                    // 准确性
                    String accuracyCorrectProbability = df.format((float) qualityAuditor.getAccuracyCorrect() / (qualityAuditor.getAccuracyCorrect() + qualityAuditor.getAccuracyError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setAccuracyCorrectProbability(accuracyCorrectProbability);
                    String accuracyErrorProbability = df.format((float) qualityAuditor.getAccuracyError() / (qualityAuditor.getAccuracyCorrect() + qualityAuditor.getAccuracyError())* 100) + "%";//返回的是String类型
                    qualityAuditorDto.setAccuracyErrorProbability(accuracyErrorProbability);
                }
            }

            qualityAuditorDtoList.add(qualityAuditorDto);
        }

        return ResponseEntity.ok(new ResultMap(tokenUtils).successAndRefreshToken(request).payloads(qualityAuditorDtoList));
    }

    public static void main(String[] args) {
        int resultLimit = 10000;
        int limit = -1;
        int count = limit > resultLimit ? resultLimit : limit > 0 ? limit : resultLimit;
        System.out.println(count);
    }


}