513 lines
19 KiB
Java
513 lines
19 KiB
Java
package com.gunshi.project.xyt.service;
|
|
|
|
import cn.hutool.core.bean.BeanUtil;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
|
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
import com.gunshi.project.xyt.entity.dto.*;
|
|
import com.gunshi.project.xyt.model.*;
|
|
import com.gunshi.project.xyt.model.StDamBAutoDao;
|
|
import com.gunshi.project.xyt.model.StEqptBAutoDao;
|
|
import com.gunshi.project.xyt.model.StGateBAutoDao;
|
|
import com.gunshi.project.xyt.model.StResBAutoDao;
|
|
import com.gunshi.project.xyt.model.StResStcdRefAutoDao;
|
|
import com.gunshi.project.xyt.model.StRvBAutoDao;
|
|
import com.gunshi.project.xyt.so.*;
|
|
import jakarta.annotation.Resource;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import javax.print.DocFlavor;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* TODO
|
|
*
|
|
* @ClassName EngineeringDrainageServiceImpl
|
|
* @Author Huang Qianxiang
|
|
* @Date 2024/1/24 14:38
|
|
*/
|
|
@Service
|
|
@Slf4j
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public class EngineeringDrainageService {
|
|
|
|
@Resource
|
|
private StResBAutoDao stResBAutoDao;
|
|
@Resource
|
|
private StResStcdRefAutoDao stResStcdRefAutoDao;
|
|
@Resource
|
|
private StRvBAutoDao stRvBAutoDao;
|
|
@Resource
|
|
private StDamBAutoDao stDamBAutoDao;
|
|
@Resource
|
|
private StGateBAutoDao stGateBAutoDao;
|
|
@Resource
|
|
private StEqptBAutoDao stEqptBAutoDao;
|
|
|
|
|
|
|
|
/**
|
|
* 新增水库基础信息
|
|
* @param stResDto 水库的基础信息
|
|
*/
|
|
public void insertStRes(StResDto stResDto) {
|
|
StResB stResB = new StResB();
|
|
BeanUtil.copyProperties(stResDto,stResB);
|
|
Long resId = IdWorker.getId();
|
|
stResB.setResId(resId);
|
|
stResB.setStatus(1);
|
|
Date date = new Date();
|
|
stResB.setTm(date);
|
|
|
|
//判断水库代码是否唯一
|
|
if (queryByResCode(stResDto.getResCode()) != null){
|
|
throw new IllegalArgumentException("水库代码必须唯一");
|
|
}
|
|
|
|
//保存水库基本信息
|
|
stResBAutoDao.save(stResB);
|
|
}
|
|
|
|
/**
|
|
* 更新水库的基础信息
|
|
* @param stResDto 水库的基础信息
|
|
*/
|
|
public void updateStRes(StResDto stResDto) {
|
|
Long resId = stResDto.getResId();
|
|
StResB byId = stResBAutoDao.getById(resId);
|
|
if (byId == null) {
|
|
throw new IllegalArgumentException("resId:" + resId + "不存在");
|
|
}
|
|
//判断水库代码是否唯一
|
|
if (queryByResCode(stResDto.getResCode()) != null){
|
|
throw new IllegalArgumentException("水库代码必须唯一");
|
|
}
|
|
|
|
StResB stResB = new StResB();
|
|
BeanUtil.copyProperties(stResDto,stResB);
|
|
Date date = new Date();
|
|
stResB.setTm(date);
|
|
//更新水库基本信息
|
|
stResBAutoDao.updateById(stResB);
|
|
}
|
|
|
|
/**
|
|
* 根据水库ID删除水库基本信息
|
|
* @param resId 水库ID
|
|
*/
|
|
public void deleteStRes(String resId) {
|
|
QueryWrapper<StResB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StResB.COL_RES_ID,resId)
|
|
.eq(StResB.COL_STATUS,1);
|
|
StResB byId = stResBAutoDao.getOne(queryWrapper);
|
|
if (byId == null) {
|
|
throw new IllegalArgumentException("resId:" + resId + "不存在");
|
|
}
|
|
UpdateWrapper<StResB> updateWrapper = new UpdateWrapper<>();
|
|
//水库状态更新为禁用
|
|
updateWrapper.eq(StResB.COL_RES_ID,resId)
|
|
.set(StResB.COL_STATUS,0);
|
|
stResBAutoDao.update(updateWrapper);
|
|
}
|
|
|
|
|
|
/**
|
|
* 分页查询水库基本信息
|
|
* @param stResPageSo 水库基本信息查询参数
|
|
* @return
|
|
*/
|
|
public Page<StResB> pageStRes(StResPageSo stResPageSo){
|
|
if (StringUtils.isNotEmpty(stResPageSo.getResId())){
|
|
StResB stResB = stResBAutoDao.getById(stResPageSo.getResId());
|
|
if (stResB == null){
|
|
return null;
|
|
}
|
|
List<StResB> resBList = List.of(stResB);
|
|
return new Page<StResB>(1,1,1).setRecords(resBList);
|
|
}
|
|
|
|
LambdaQueryWrapper<StResB> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(stResPageSo.getResName())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stResPageSo.getResName()),StResB::getResName,stResPageSo.getResName());
|
|
}
|
|
if (StringUtils.isNotEmpty(stResPageSo.getResCode())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stResPageSo.getResCode()),StResB::getResCode,stResPageSo.getResCode());
|
|
}
|
|
if (StringUtils.isNotEmpty(stResPageSo.getEngScal())){
|
|
lambdaQueryWrapper.eq(StringUtils.isNotEmpty(stResPageSo.getEngScal()),StResB::getEngScal,stResPageSo.getEngScal());
|
|
}
|
|
if (stResPageSo.getStatus() != null){
|
|
lambdaQueryWrapper.eq(StResB::getStatus,stResPageSo.getStatus());
|
|
}
|
|
return stResBAutoDao.page(stResPageSo.getPageSo().toPage(),lambdaQueryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 根据水库代码查询水库的基础信息
|
|
* @param resCode 水库代码
|
|
* @return 水库的基础信息
|
|
*/
|
|
public StResB queryByResCode(String resCode) {
|
|
QueryWrapper<StResB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StResB.COL_RES_CODE,resCode);
|
|
return stResBAutoDao.getOne(queryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 新增河流基础信息
|
|
* @param stRvDto 河流的基础信息DTO
|
|
*/
|
|
public void insertStRv(StRvDto stRvDto) {
|
|
if (queryByResCode(stRvDto.getRvCode()) != null){
|
|
throw new IllegalArgumentException("河流代码必须唯一");
|
|
}
|
|
StRvB stRvB = new StRvB();
|
|
BeanUtil.copyProperties(stRvDto,stRvB);
|
|
Long rvId = IdWorker.getId();
|
|
stRvB.setRvId(rvId);
|
|
stRvB.setStatus(1);
|
|
stRvB.setTm(new Date());
|
|
stRvBAutoDao.save(stRvB);
|
|
}
|
|
|
|
/**
|
|
* 更新河流的基础信息
|
|
* @param stRvB 河流的基础信息
|
|
*/
|
|
public void updateStRv(StRvB stRvB) {
|
|
Long rvId = stRvB.getRvId();
|
|
StRvB byId = stRvBAutoDao.getById(rvId);
|
|
if (byId == null){
|
|
throw new IllegalArgumentException("河流ID: " + rvId + "不存在");
|
|
}
|
|
stRvB.setTm(new Date());
|
|
stRvBAutoDao.updateById(stRvB);
|
|
}
|
|
|
|
/**
|
|
* 根据河流ID删除河流信息
|
|
* @param rvId 河流ID
|
|
*/
|
|
public void deleteStRv(String rvId) {
|
|
QueryWrapper<StRvB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StRvB.COL_RV_ID,rvId)
|
|
.eq(StRvB.COL_STATUS,1);
|
|
StRvB byId = stRvBAutoDao.getOne(queryWrapper);
|
|
if (byId == null){
|
|
throw new IllegalArgumentException("河流ID: " + rvId + "不存在, 或河流ID: " + rvId + "已被禁用");
|
|
}
|
|
UpdateWrapper<StRvB> updateWrapper = new UpdateWrapper<>();
|
|
updateWrapper.eq(StRvB.COL_RV_ID,rvId)
|
|
.set(StRvB.COL_STATUS,0);
|
|
stRvBAutoDao.update(updateWrapper);
|
|
}
|
|
|
|
/**
|
|
* 分页查询河流基础信息
|
|
* @param stRvPageSo 河流基本信息查询参数
|
|
*/
|
|
public Page<StRvB> pageStRv(StRvPageSo stRvPageSo){
|
|
if (StringUtils.isNotEmpty(stRvPageSo.getRvId())){
|
|
StRvB stRvB = stRvBAutoDao.getById(stRvPageSo.getRvId());
|
|
if (stRvB == null){
|
|
return null;
|
|
}
|
|
List<StRvB> rvBList = List.of(stRvB);
|
|
return new Page<StRvB>(1,1,1).setRecords(rvBList);
|
|
}
|
|
|
|
LambdaQueryWrapper<StRvB> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(stRvPageSo.getRvName())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stRvPageSo.getRvName()),StRvB::getRvCode,stRvPageSo.getRvName());
|
|
}
|
|
if (StringUtils.isNotEmpty(stRvPageSo.getRvCode())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stRvPageSo.getRvCode()),StRvB::getRvCode,stRvPageSo.getRvCode());
|
|
}
|
|
if (stRvPageSo.getStatus() != null){
|
|
lambdaQueryWrapper.eq(StRvB::getStatus,stRvPageSo.getStatus());
|
|
}
|
|
return stRvBAutoDao.page(stRvPageSo.getPageSo().toPage(),lambdaQueryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 根据河流代码查询河流的基础信息
|
|
* @param rvCode 河流代码
|
|
* @return 河流的基础信息
|
|
*/
|
|
public StRvB queryByRvCode(String rvCode) {
|
|
QueryWrapper<StRvB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StRvB.COL_RV_CODE,rvCode)
|
|
.eq(StRvB.COL_STATUS,1);
|
|
return stRvBAutoDao.getOne(queryWrapper);
|
|
}
|
|
|
|
|
|
/**
|
|
* 新增大坝基础信息
|
|
* @param stDamDto 大坝基础信息DTO
|
|
*/
|
|
public void insertStDam(StDamDto stDamDto) {
|
|
if (queryByDamCode(stDamDto.getDamCode()) != null){
|
|
throw new IllegalArgumentException("大坝代码必须唯一");
|
|
}
|
|
StDamB stDamB = new StDamB();
|
|
BeanUtil.copyProperties(stDamDto,stDamB);
|
|
Long damId = IdWorker.getId();
|
|
stDamB.setDamId(damId);
|
|
stDamB.setStatus(1);
|
|
stDamB.setTm(new Date());
|
|
stDamBAutoDao.save(stDamB);
|
|
}
|
|
|
|
/**
|
|
* 更新大坝基础信息
|
|
* @param stDamB 大坝基础信息
|
|
*/
|
|
public void updateStDam(StDamB stDamB) {
|
|
Long damId = stDamB.getDamId();
|
|
StDamB byId = stDamBAutoDao.getById(damId);
|
|
if (byId == null){
|
|
throw new IllegalArgumentException("大坝ID: " + damId + "不存在");
|
|
}
|
|
stDamB.setTm(new Date());
|
|
stDamBAutoDao.updateById(stDamB);
|
|
}
|
|
|
|
/**
|
|
* 根据大坝ID删除大坝基础信息
|
|
* @param damId 大坝ID
|
|
*/
|
|
public void deleteStDam(String damId) {
|
|
StDamB byId = stDamBAutoDao.getById(damId);
|
|
if (byId == null){
|
|
throw new IllegalArgumentException("大坝ID: " + damId + "不存在");
|
|
}
|
|
UpdateWrapper<StDamB> updateWrapper = new UpdateWrapper<>();
|
|
updateWrapper.eq(StDamB.COL_DAM_ID,damId)
|
|
.set(StDamB.COL_STATUS,0);
|
|
stDamBAutoDao.update(updateWrapper);
|
|
}
|
|
|
|
/**
|
|
* 分页查询大坝基础信息
|
|
* @param stDamPageSo 大坝基本信息查询参数
|
|
* @return
|
|
*/
|
|
public Page<StDamB> pageStDam(StDamPageSo stDamPageSo){
|
|
if (StringUtils.isNotEmpty(stDamPageSo.getDamId())){
|
|
StDamB stDamB = stDamBAutoDao.getById(stDamPageSo.getDamId());
|
|
if (stDamB == null){
|
|
return null;
|
|
}
|
|
List<StDamB> damBList = List.of(stDamB);
|
|
return new Page<StDamB>(1,1,1).setRecords(damBList);
|
|
}
|
|
LambdaQueryWrapper<StDamB> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(stDamPageSo.getDamName())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stDamPageSo.getDamName()),StDamB::getDamName,stDamPageSo.getDamName());
|
|
}
|
|
if (StringUtils.isNotEmpty(stDamPageSo.getDamCode())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stDamPageSo.getDamCode()),StDamB::getDamCode,stDamPageSo.getDamCode());
|
|
}
|
|
if (stDamPageSo.getStatus() != null){
|
|
lambdaQueryWrapper.eq(StDamB::getStatus,stDamPageSo.getStatus());
|
|
}
|
|
return stDamBAutoDao.page(stDamPageSo.getPageSo().toPage(),lambdaQueryWrapper);
|
|
|
|
}
|
|
|
|
/**
|
|
* 根据大坝代码查询大坝信息
|
|
* @param damCode 大坝代码
|
|
* @return 大坝基础信息
|
|
*/
|
|
public StDamB queryByDamCode(String damCode) {
|
|
QueryWrapper<StDamB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StDamB.COL_DAM_CODE,damCode)
|
|
.eq(StDamB.COL_STATUS,1);
|
|
return stDamBAutoDao.getOne(queryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 新增闸阀基础信息
|
|
* @param stGateDto 闸阀基础信息DTO
|
|
*/
|
|
public void insertStGate(StGateDto stGateDto){
|
|
if (queryByGateCode(stGateDto.getGateCd()) != null){
|
|
throw new IllegalArgumentException("闸阀编码必须唯一");
|
|
}
|
|
StGateB stGateB = new StGateB();
|
|
BeanUtil.copyProperties(stGateDto,stGateB);
|
|
long gateId = IdWorker.getId();
|
|
stGateB.setGateId(gateId);
|
|
stGateB.setTm(new Date());
|
|
stGateBAutoDao.save(stGateB);
|
|
}
|
|
|
|
/**
|
|
* 更新闸阀基础信息
|
|
* @param stGateB 闸阀基础信息
|
|
*/
|
|
public void updateStGate(StGateB stGateB){
|
|
Long gateId = stGateB.getGateId();
|
|
StGateB byId = stGateBAutoDao.getById(gateId);
|
|
if (byId == null){
|
|
throw new IllegalArgumentException("闸阀ID : " + gateId + "不存在");
|
|
}
|
|
stGateB.setTm(new Date());
|
|
stGateBAutoDao.updateById(stGateB);
|
|
}
|
|
|
|
/**
|
|
* 根据闸阀ID删除闸阀基础信息
|
|
* @param gateId 闸阀ID
|
|
*/
|
|
public void deleteStGate(String gateId){
|
|
QueryWrapper<StGateB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StGateB.COL_GATE_ID,gateId)
|
|
.eq(StGateB.COL_STATUS,1);
|
|
StGateB stGateB = stGateBAutoDao.getById(gateId);
|
|
if (stGateB == null){
|
|
throw new IllegalArgumentException("闸阀ID : " + gateId + "不存在或闸阀ID : " + gateId + "已被禁用");
|
|
}
|
|
UpdateWrapper<StGateB> updateWrapper = new UpdateWrapper<>();
|
|
updateWrapper.eq(StGateB.COL_GATE_ID,gateId)
|
|
.set(StGateB.COL_STATUS,0);
|
|
stGateBAutoDao.update(updateWrapper);
|
|
}
|
|
|
|
/**
|
|
* 根据闸阀编码查询闸阀基础信息
|
|
* @param gateCd 闸阀编码
|
|
* @return 闸阀基础信息
|
|
*/
|
|
public StGateB queryByGateCode(String gateCd){
|
|
QueryWrapper<StGateB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StGateB.COL_GATE_CD,gateCd)
|
|
.eq(StGateB.COL_STATUS,1);
|
|
return stGateBAutoDao.getOne(queryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 分页查询闸阀基础信息
|
|
* @param stGatePageSo 闸阀基本信息查询参数
|
|
* @return
|
|
*/
|
|
public Page<StGateB> pageStGate(StGatePageSo stGatePageSo){
|
|
if (StringUtils.isNotEmpty(stGatePageSo.getGateId())){
|
|
StGateB stGateB = stGateBAutoDao.getById(stGatePageSo.getGateId());
|
|
if (stGateB == null){
|
|
return null;
|
|
}
|
|
List<StGateB> gateBList = List.of(stGateB);
|
|
return new Page<StGateB>(1,1,1).setRecords(gateBList);
|
|
}
|
|
LambdaQueryWrapper<StGateB> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(stGatePageSo.getGateNm())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stGatePageSo.getGateNm()),StGateB::getGateNm,stGatePageSo.getGateNm());
|
|
}
|
|
if (StringUtils.isNotEmpty(stGatePageSo.getGateCd())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stGatePageSo.getGateCd()),StGateB::getGateCd,stGatePageSo.getGateCd());
|
|
}
|
|
if (stGatePageSo.getStatus() != null){
|
|
lambdaQueryWrapper.eq(StGateB::getStatus,stGatePageSo.getStatus());
|
|
}
|
|
return stGateBAutoDao.page(stGatePageSo.getPageSo().toPage(),lambdaQueryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 新增量水堰基础信息
|
|
* @param stEqptDto 量水堰基础信息DTO
|
|
*/
|
|
public void insertStEqpt(StEqptDto stEqptDto){
|
|
if (queryByWmegCode(stEqptDto.getWmeqCode()) != null){
|
|
throw new IllegalArgumentException("量水设施代码不能为空");
|
|
}
|
|
StEqptB stEqptB = new StEqptB();
|
|
BeanUtil.copyProperties(stEqptDto,stEqptB);
|
|
long id = IdWorker.getId();
|
|
stEqptB.setWmeqId(id);
|
|
stEqptB.setStatus(1);
|
|
stEqptBAutoDao.save(stEqptB);
|
|
}
|
|
|
|
/**
|
|
* 更新量水堰基础信息
|
|
* @param stEqptB 量水堰基础信息
|
|
*/
|
|
public void updateStEqpt(StEqptB stEqptB){
|
|
Long wmeqId = stEqptB.getWmeqId();
|
|
StEqptB stEqptB1 = stEqptBAutoDao.getById(wmeqId);
|
|
if (stEqptB1 == null){
|
|
throw new IllegalArgumentException("量水设施ID: " + wmeqId + "不存在");
|
|
}
|
|
stEqptBAutoDao.updateById(stEqptB);
|
|
}
|
|
|
|
/**
|
|
* 根据量水设施ID删除量水堰基础信息
|
|
* @param wmeqId 量水设施ID
|
|
*/
|
|
public void deleteStEqpt(String wmeqId){
|
|
QueryWrapper<StEqptB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StEqptB.COL_WMEQ_ID,wmeqId)
|
|
.eq(StEqptB.COL_STATUS,1);
|
|
StEqptB stEqptB1 = stEqptBAutoDao.getOne(queryWrapper);
|
|
if (stEqptB1 == null){
|
|
throw new IllegalArgumentException("量水设施ID: " + wmeqId + "不存在或量水设施ID: " + wmeqId + "被禁用");
|
|
}
|
|
UpdateWrapper<StEqptB> updateWrapper = new UpdateWrapper<>();
|
|
updateWrapper.eq(StEqptB.COL_WMEQ_ID,wmeqId)
|
|
.set(StEqptB.COL_STATUS,0);
|
|
stEqptBAutoDao.update(updateWrapper);
|
|
}
|
|
|
|
/**
|
|
* 分页查询量水堰基础信息
|
|
* @param stEqptPageSo 量水堰基本信息查询参数
|
|
* @return
|
|
*/
|
|
public Page<StEqptB> pageStEqpt(StEqptPageSo stEqptPageSo){
|
|
if (StringUtils.isNotEmpty(stEqptPageSo.getWmeqId())){
|
|
StEqptB stEqptB = stEqptBAutoDao.getById(stEqptPageSo.getWmeqId());
|
|
if (stEqptB == null){
|
|
return null;
|
|
}
|
|
List<StEqptB> eqptBList = List.of(stEqptB);
|
|
return new Page<StEqptB>(1,1,1).setRecords(eqptBList);
|
|
}
|
|
LambdaQueryWrapper<StEqptB> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(stEqptPageSo.getWmeqName())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stEqptPageSo.getWmeqName()),StEqptB::getWmeqName,stEqptPageSo.getWmeqName());
|
|
}
|
|
if (StringUtils.isNotEmpty(stEqptPageSo.getWmeqCode())){
|
|
lambdaQueryWrapper.like(StringUtils.isNotEmpty(stEqptPageSo.getWmeqCode()),StEqptB::getWmeqCode,stEqptPageSo.getWmeqCode());
|
|
}
|
|
if (stEqptPageSo.getStatus() != null){
|
|
lambdaQueryWrapper.eq(StEqptB::getStatus,stEqptPageSo.getStatus());
|
|
}
|
|
return stEqptBAutoDao.page(stEqptPageSo.getPageSo().toPage(),lambdaQueryWrapper);
|
|
}
|
|
|
|
/**
|
|
* 根据量水堰代码查询量水堰基础信息
|
|
* @param wmeqCode 量水堰代码
|
|
* @return 量水堰基础信息
|
|
*/
|
|
public StEqptB queryByWmegCode(String wmeqCode){
|
|
QueryWrapper<StEqptB> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq(StEqptB.COL_WMEQ_CODE,wmeqCode)
|
|
.eq(StEqptB.COL_STATUS,1);
|
|
StEqptB stEqptB = stEqptBAutoDao.getOne(queryWrapper);
|
|
return stEqptB;
|
|
}
|
|
|
|
}
|