zl-opd-server/src/main/java/com/hb/proj/analysis/controller/ProduceParamController.java

package com.hb.proj.analysis.controller;

import java.io.File;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.validation.annotation.Validated;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.hb.proj.allconfig.AccessToken;
import com.hb.proj.allconfig.BusinessException;
import com.hb.proj.allconfig.SysLog;
import com.hb.proj.analysis.service.IPRService;
import com.hb.proj.analysis.service.ProduceParamCalculator;
import com.hb.proj.analysis.service.ProduceParamService;
import com.hb.proj.model.WellAnalysisParamPO;
import com.hb.proj.model.WellMeasurePO;
import com.hb.proj.model.WellMeasureVO;
import com.hb.proj.model.WellPumpPO;
import com.hb.proj.utils.DownloadUtils;
import com.hb.proj.utils.RespVO;
import com.hb.proj.utils.RespVOBuilder;
import com.hb.xframework.dao.util.PageModel;
import com.hb.xframework.util.MapUtils;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;

@RestController
@RequestMapping("/analysis/produce")
@Validated
public class ProduceParamController {

	@Autowired
	private ProduceParamService  service;
	
	@Autowired
	private RedisTemplate<String,Object> redisTemplate;
	
	@Autowired
	private IPRService iprService;
	
	
	
	/**
	 * 下载测量数据导入模板
	 * @param request
	 * @param response
	 */
	@RequestMapping("/downloadMeasureXlsTmp")
	public void download(HttpServletRequest request,HttpServletResponse response) {
		String basePath=request.getSession().getServletContext().getRealPath("");
		File downloadFile=new File(basePath+File.separator+"download/tmp/measure.xls");
		if(!downloadFile.exists()) {
			throw new BusinessException("文件不存在");
		}
		
		String displayName="计量数据导入模板";
		
		DownloadUtils.download(downloadFile, displayName,response);
	}
	
	/**
	 * 分页查询测量数据(附加的独立测量数据管理页面)
	 */
	@RequestMapping("/queryMeasureParamList")
	public RespVO<PageModel<WellMeasureVO>> queryMeasureParamList(String wellName,
			Date startTime,Date endTime,
			@RequestParam(value = "currentPage", defaultValue = "1") Integer pageNum,
			@RequestParam(value = "pageSize", defaultValue = "20") Integer pageSize) {
		
		return RespVOBuilder.ok(service.queryMeasureParamList(wellName,startTime,endTime, pageNum, pageSize));
	}
	
	/**
	 * 删除单个计量数据
	 * @param measureId  待删除记录id
	 * @return
	 */
	@RequestMapping("/deleteMeasureParam")
	@SysLog("删除计量数据：{arg0}")
	public RespVO<Object> deleteMeasureParam(@NotBlank(message="缺少记录号") String measureId){
		service.deleteMeasureParam(measureId);
		return RespVOBuilder.ok();
	}
	
	/**
	 * 分页查询测量数据
	 */
	@RequestMapping("/queryMeasureParam")
	public RespVO<PageModel<WellMeasurePO>> queryMeasureParam(@NotBlank(message="缺少井号") String wellId,
			Date startTime,Date endTime,
			@RequestParam(value = "currentPage", defaultValue = "1") Integer pageNum,
			@RequestParam(value = "pageSize", defaultValue = "20") Integer pageSize) {
		
		return RespVOBuilder.ok(service.queryMeasureParam(wellId,startTime,endTime, pageNum, pageSize));
	}
	
	/**
	 * 分页查询抽油泵数据
	 */
	@RequestMapping("/queryPump")
	public RespVO<PageModel<WellPumpPO>> queryPump(@NotBlank(message="缺少井号") String wellId,
			Date startTime,Date endTime,
			@RequestParam(value = "currentPage", defaultValue = "1") Integer pageNum,
			@RequestParam(value = "pageSize", defaultValue = "20") Integer pageSize) {
		
		
		return RespVOBuilder.ok(service.queryPump(wellId,startTime,endTime, pageNum, pageSize));
	}
	
	
	/**
	 * 分页查询分析参数
	 */
	@RequestMapping("/queryAnalysisParam")
	public RespVO<PageModel<WellAnalysisParamPO>> queryAnalysisParam(@NotBlank(message="缺少井号") String wellId,
			Date startTime,Date endTime,
			@RequestParam(value = "currentPage", defaultValue = "1") Integer pageNum,
			@RequestParam(value = "pageSize", defaultValue = "20") Integer pageSize) {
		
		
		return RespVOBuilder.ok(service.queryAnalysisParam(wellId,startTime,endTime, pageNum, pageSize));
	}
	
	/**
	 * 获得指定井的最新生成动态参数
	 * @param wellId
	 * @return
	 */
	@RequestMapping("/getLastParam")
	public RespVO<Object> getLastParam(@NotBlank(message="缺少井号") String wellId){
		return RespVOBuilder.ok(MapUtils.build("measure", service.getLastMeasureParam(wellId), 
				"analysis",service.getLastAnalysisParam(wellId),
				"pump",service.getLastPumpParam(wellId),
				"regression",iprService.getLastRegression(wellId)
				));
	}
	
	/**
	 * 保存油井测量参数
	 * @param measure
	 * @param token
	 * @return
	 */
	@RequestMapping("/saveMeasure")
	public RespVO<Object> saveMeasure(@Validated WellMeasurePO  measure,AccessToken token){
		if(measure.getWellBtmCompCoe()!=null && measure.getWellBtmCompCoe()!=0) {
			measure.setSurfaceCompCoe(1/measure.getWellBtmCompCoe());
		}
		measure.setModifyBy(token!=null?token.getUsName():"unknow");
		
		if(StringUtils.isBlank(measure.getMeasureId())) {
			measure.setCreateBy(token!=null?token.getUsName():"unknow");
			service.addMeasureParam(measure);
		}
		else {
			WellMeasurePO  dbPO=service.getMeasureParam(measure.getMeasureId());
			if(dbPO==null) {
				return RespVOBuilder.error("记录已不存在");
			}
			measure.setCreateTime(dbPO.getCreateTime());
			service.updateMeasureParam(measure);
		}
		return RespVOBuilder.ok();
	}
	
	/**
	 * 油井测量参数(独立菜单-计量数据 只维护：测量日期、井名、含水率、计量液量)
	 * 修改：
	 * 新增：
	 * @param measures
	 * @param token
	 * @return
	 */
	@PostMapping("/saveMeasureList")
	public RespVO<Object> saveMeasureList(@RequestBody @Valid List<WellMeasurePO> measures,@NotNull(message="缺少登录信息") AccessToken token){
		if(measures==null || measures.size()==0) {
			return RespVOBuilder.error("缺少计量数据");
		}
		for(WellMeasurePO measure : measures) {
			if(StringUtils.isNotBlank(measure.getMeasureId())) {
				WellMeasurePO  dbPO=service.getMeasureParam(measure.getMeasureId());
				if(dbPO==null) {
					return RespVOBuilder.error("被更新记录已不存在");
				}
				dbPO.setWaterRatio(measure.getWaterRatio());
				dbPO.setMeteredLiquidYield(measure.getMeteredLiquidYield());
				dbPO.setStartTime(measure.getStartTime());
				dbPO.setModifyBy(token.getUsName());
				service.updateMeasureParam(measure);
			}
			else {
				measure.setModifyBy(token.getUsName());
				measure.setCreateBy(token.getUsName());
				service.addMeasureParam(measure);
			}
		}
		return RespVOBuilder.ok();
	}
	
	/**
	 * 保存抽油泵参数
	 * @param pump
	 * @param token
	 * @return
	 */
	@RequestMapping("/savePump")
	public RespVO<Object>  savePump(@Validated WellPumpPO pump,AccessToken token){
		pump.setModifyBy(token!=null?token.getUsName():"unknow");
		ProduceParamCalculator.calcPumpExtra(pump);
		if(StringUtils.isBlank(pump.getPumpId())) {
			pump.setCreateBy(token!=null?token.getUsName():"unknow");
			service.addPumpParam(pump);
		}
		else {
			WellPumpPO  dbPO=service.getPumpParam(pump.getPumpId());
			if(dbPO==null) {
				return RespVOBuilder.error("记录已不存在");
			}
			pump.setCreateTime(dbPO.getCreateTime());
			service.updatePumpParam(pump);
		}
		return RespVOBuilder.ok();
	}
	
	/**
	 * 保存分析参数(只新增)
	 * @param pump
	 * @param token
	 * @return
	 */
	@RequestMapping("/saveAnalysisParam")
	public RespVO<Object>  saveAnalysisParam(@Validated WellAnalysisParamPO analysisParam,AccessToken token){
		analysisParam.setModifyBy(token!=null?token.getUsName():"unknow");
		analysisParam.setCreateBy(analysisParam.getModifyBy());
		service.addAnalysisParam(analysisParam);
		return RespVOBuilder.ok();
	}
	
	/**
	 * 计算分析参数
	 * @param wellId
	 * @return
	 */
	@RequestMapping("/calcParam")
	public RespVO<Object>  calcParam(@NotBlank(message="缺少井号") String wellId){
		
		WellMeasurePO measure=service.getLastMeasureParam(wellId);
		if(measure==null) {
			return RespVOBuilder.error("缺少该井的测量数据");
		}
		
		WellPumpPO pump=service.getLastPumpParam(wellId);
		if(pump==null) {
			return RespVOBuilder.error("缺少该井的泵数据");
		}
		
		/*
		WellAnalysisParamPO analysis=service.getLastAnalysisParam(wellId);
		
		//引用相同数据计算过
		if(analysis!=null && analysis.getRefMeasureId().equals(measure.getMeasureId()) && analysis.getRefPumpId().equals(pump.getPumpId()) ) {
			return RespVOBuilder.ok();
		}*/
		
		//实时采集数据:冲次（要求单位 次/min）
		Double freq=(Double)redisTemplate.opsForHash().get(wellId,"freq");
		
		//计算出新的分析参数
		WellAnalysisParamPO analysis=ProduceParamCalculator.calc(measure, pump, freq);
		analysis.setWellId(wellId);
		service.addAnalysisParam(analysis);
		
		return RespVOBuilder.ok(analysis);
	}
}