package com.dy.pipIrrWechat.irrigatePlan;
|
|
import com.alibaba.fastjson2.JSON;
|
import com.alibaba.fastjson2.JSONArray;
|
import com.alibaba.fastjson2.JSONObject;
|
import com.dy.common.webUtil.BaseResponseUtils;
|
import com.dy.pipIrrGlobal.daoIr.*;
|
import com.dy.pipIrrGlobal.daoRm.RmCommandHistoryMapper;
|
import com.dy.pipIrrGlobal.pojoIr.IrIrrigatePlan;
|
import com.dy.pipIrrGlobal.pojoIr.IrIrrigateSchedule;
|
import com.dy.pipIrrGlobal.pojoIr.IrPlanOperate;
|
import com.dy.pipIrrGlobal.pojoIr.IrPlanSchedule;
|
import com.dy.pipIrrGlobal.voIr.*;
|
import com.dy.pipIrrGlobal.voRm.VoIntakeVc;
|
import com.dy.pipIrrWechat.irrigatePlan.dto.PlanSimple;
|
import com.dy.pipIrrWechat.irrigatePlan.enums.OperateTypeENUM;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.ibatis.annotations.Param;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
|
/**
|
* @author ZhuBaoMin
|
* @date 2025-02-20 15:27
|
* @LastEditTime 2025-02-20 15:27
|
* @Description
|
*/
|
|
@Slf4j
|
@Service
|
public class IrrigatePlanSv {
|
@Autowired
|
private IrIrrigatePlanMapper irrigatePlanMapper;
|
|
@Autowired
|
private IrPlanOperateMapper irPlanOperateMapper;
|
|
@Autowired
|
private IrIrrigateScheduleMapper irIrrigateScheduleMapper;
|
|
@Autowired
|
private IrOpeningScheduleMapper irOpeningScheduleMapper;
|
|
@Autowired
|
private IrIrrigateGroupMapper irIrrigateGroupMapper;
|
|
@Autowired
|
private IrIrrigateUnitMapper irIrrigateUnitMapper;
|
|
@Autowired
|
private IrPlanScheduleMapper irPlanScheduleMapper;
|
|
@Autowired
|
private IrGroupIntakeMapper irGroupIntakeMapper;
|
|
@Autowired
|
private IrIntakeOperateMapper irIntakeOperateMapper;
|
|
@Autowired
|
private RmCommandHistoryMapper rmdCommandHistoryMapper;
|
|
/**
|
* 添加灌溉计划
|
* @param po
|
* @return
|
*/
|
public Long addIrrigatePlan(IrIrrigatePlan po) {
|
irrigatePlanMapper.insert(po);
|
return po.getId();
|
}
|
|
/**
|
* 删除灌溉计划
|
* @param planSimple
|
* @return
|
*/
|
public Map deletePlan(PlanSimple planSimple) {
|
Long planId = planSimple.getPlanId();
|
Long operatorId = planSimple.getOperatorId();
|
|
Integer planState = irrigatePlanMapper.getPlanState(planId);
|
if(planState == null) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("msg", "灌溉计划不存在");
|
map.put("content", null);
|
return map;
|
}
|
if(planState != 1) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("msg", "灌溉计划非草稿状态，不允许删除");
|
map.put("content", null);
|
return map;
|
}
|
|
try {
|
irrigatePlanMapper.deleteByPrimaryKey(planId);
|
// 添加灌溉计划操作记录
|
IrPlanOperate planOperate = new IrPlanOperate();
|
planOperate.setPlanId(planId);
|
planOperate.setOperator(operatorId);
|
planOperate.setOperateType(OperateTypeENUM.DELETE.getCode());
|
planOperate.setOperateTime(new Date());
|
addPlanOperate(planOperate);
|
|
Map map = new HashMap<>();
|
map.put("success", true);
|
map.put("msg", "灌溉项目删除成功");
|
map.put("content", null);
|
return map;
|
} catch (Exception e) {
|
Map map = new HashMap<>();
|
map.put("success", false);
|
map.put("msg", "灌溉项目删除失败");
|
map.put("content", null);
|
return map;
|
}
|
}
|
|
/**
|
* 根据计划ID获取待终止计划的结束时间：未删除、未终止、已发布、当前时间小于计划结束时间
|
* @param planId
|
* @return
|
*/
|
public Date getToTerminatePlan(Long planId) {
|
return irrigatePlanMapper.getToTerminatePlan(planId);
|
}
|
|
/**
|
* 根据计划ID获取待终止的取水口ID（已发布开发命令，无论是否成功）
|
* @param planId
|
* @return
|
*/
|
public List<Long> getToTerminateIntakeIds(Long planId) {
|
return irIntakeOperateMapper.getToTerminateIntakeIds(planId);
|
}
|
|
/**
|
* 根据计划ID获取待终止的命令ID列表
|
* @param planId
|
* @return
|
*/
|
public List<Long> getTerminateCommandIds(Long planId) {
|
return irIntakeOperateMapper.getTerminateCommandIds(planId);
|
}
|
|
/**
|
* 根据计划ID获取待终止的取水口列表（开阀成功的）
|
* @param planId
|
* @return
|
*/
|
public List<VoToTerminateIntakes> getToTerminateIntakes(Long planId) {
|
return irIntakeOperateMapper.getToTerminateIntakes(planId);
|
}
|
|
/**
|
* 根据命令日志ID获取取水口及虚拟卡信息，终止灌溉计划时使用，用来执行远程关阀
|
* @param commandId
|
* @return
|
*/
|
public VoIntakeVc getValveOpen(Long commandId) {
|
return rmdCommandHistoryMapper.getValveOpen(commandId);
|
}
|
|
/**
|
* 修改灌溉计划
|
* @param po
|
* @return
|
*/
|
public Integer updatePlan(IrIrrigatePlan po) {
|
return irrigatePlanMapper.updateByPrimaryKeySelective(po);
|
}
|
|
/**
|
* 获取未完成的计划列表，小程序计划列表页使用
|
* @return
|
*/
|
public List<VoPlans> getNotCompletePlans() {
|
return irrigatePlanMapper.getNotCompletePlans();
|
}
|
|
/**
|
* 获取已完成的计划列表，小程序计划列表页使用
|
* @return
|
*/
|
public List<VoPlans> getCompletedPlans() {
|
return irrigatePlanMapper.getCompletedPlans();
|
}
|
|
/**
|
* 根据指定的计划ID获取启动模式
|
* @param planId
|
* @return
|
*/
|
public Byte getStartupMode(Long planId) {
|
return irrigatePlanMapper.getStartupMode(planId);
|
}
|
|
/**
|
* 根据指定的条件获取计划列表
|
* @param queryVo
|
* @return
|
*/
|
//public QueryResultVo<List<VoIrrigatePlan>> getIrrigatePlans(QoIrrigatePlan queryVo) {
|
// Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(queryVo);
|
//
|
// Long itemTotal = irrigatePlanMapper.getIrrigatePlanCount(params);
|
//
|
// QueryResultVo<List<VoIrrigatePlan>> rsVo = new QueryResultVo<>();
|
// rsVo.pageSize = queryVo.pageSize;
|
// rsVo.pageCurr = queryVo.pageCurr;
|
//
|
// rsVo.calculateAndSet(itemTotal, params);
|
// rsVo.obj = irrigatePlanMapper.getIrrigatePlans(params);
|
// return rsVo;
|
//}
|
|
/**
|
* 添加灌溉计划操作记录
|
* @param po
|
* @return
|
*/
|
public Long addPlanOperate(IrPlanOperate po) {
|
irPlanOperateMapper.insert(po);
|
return po.getId();
|
}
|
|
/**
|
* 添加灌溉次序记录
|
* @param po
|
* @return
|
*/
|
public Long addIrrigateSchedule(IrIrrigateSchedule po) {
|
irIrrigateScheduleMapper.insert(po);
|
return po.getId();
|
}
|
|
/**
|
* 根据计划ID终止灌溉次序，将灌溉次序的当前状态改为已终止
|
* @param planId
|
* @return
|
*/
|
public Integer terminateSchedule(Long planId) {
|
return irIrrigateScheduleMapper.terminateSchedule(planId);
|
}
|
|
/**
|
* 根据计划ID获取灌溉次序记录
|
* @param planId
|
* @return
|
*/
|
public List<VoIrrigateSchedule> getSchedulesByPlanId(Long planId) {
|
return irIrrigateScheduleMapper.getSchedulesByPlanId(planId);
|
}
|
|
/**
|
* 根据组ID获取取水口ID集合
|
* @param groupId
|
* @return
|
*/
|
public List<Long> getIntakeIdsByGroupId(Long groupId) {
|
return irGroupIntakeMapper.getIntakeIdsByGroupId(groupId);
|
}
|
|
/**
|
* 添加计划次序关联记录
|
* @param po
|
* @return
|
*/
|
public Long addPlanSchedule(IrPlanSchedule po) {
|
irPlanScheduleMapper.insert(po);
|
return po.getId();
|
}
|
|
/**
|
* 根据计划ID获取计划简单信息列表
|
* @param planId
|
* @return
|
*/
|
public VoPlanSimple getPlanSimple(Long planId) {
|
return irrigatePlanMapper.getPlanSimple(planId);
|
}
|
|
/**
|
* 根据计划ID更新计划信息（起止时间、计划状态）
|
* @param planStartTime
|
* @param planEndTime
|
* @param planId
|
* @return
|
*/
|
public Integer updatePlanTimes(Date planStartTime, Date planEndTime, Long planId) {
|
return irrigatePlanMapper.updatePlanTimes(planStartTime, planEndTime, planId);
|
}
|
|
/**
|
* 根据灌溉次序ID更新次序开始时间
|
* @param scheduleId
|
* @param startTime
|
* @return
|
*/
|
public Integer updateScheduleStartTime(Long scheduleId, Date startTime) {
|
return irIrrigateScheduleMapper.updateScheduleStartTime(scheduleId, startTime);
|
}
|
|
///**
|
// * 添加开阀计划
|
// * @param po
|
// * @return
|
// */
|
//public Long addOpeningSchedule(IrOpeningSchedule po) {
|
// irOpeningScheduleMapper.insert(po);
|
// return po.getId();
|
//}
|
|
/**
|
* 根据灌溉单元ID获取取水口ID
|
* @param unitId
|
* @return
|
*/
|
public Long getIntakeIdByUnitId(Long unitId) {
|
return irIrrigateUnitMapper.getIntakeIdByUnitId(unitId);
|
}
|
|
/**
|
* 根据计划ID获取计划发布结果
|
* @param planId
|
* @return
|
*/
|
public VoPlanDetails getPublishResults(Long planId) {
|
VoPlanDetails planDetails = irrigatePlanMapper.getPlanDetails(planId);
|
if(planDetails == null){
|
return null;
|
}
|
|
Integer failureCount = Optional.ofNullable(irIntakeOperateMapper.getFailureCount(planId)).orElse(0);
|
planDetails.setFailureCount(failureCount);
|
|
List<VoGroupResult> groupResults = irIrrigateGroupMapper.getGroupResult(planId);
|
if(groupResults == null || groupResults.size() == 0){
|
return null;
|
}
|
|
for (VoGroupResult groupResult : groupResults) {
|
List<VoIntakeResult> intakeResults = irIntakeOperateMapper.getIntakeResult(planId, groupResult.getGroupId());
|
if(intakeResults != null) {
|
groupResult.setPublishResult(intakeResults);
|
}
|
}
|
|
planDetails.setGroups(groupResults);
|
return planDetails;
|
|
}
|
}
|
