package com.gkhy.safePlatform.safeCheck.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountAuthService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountDepartmentService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountUserService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.DepInfoRPCRespDTO;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserInfoRPCRespDTO;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserRPCRespDTO;
|
import com.gkhy.safePlatform.commons.co.ContextCacheUser;
|
import com.gkhy.safePlatform.commons.enums.E;
|
import com.gkhy.safePlatform.commons.enums.ResultCodes;
|
import com.gkhy.safePlatform.commons.exception.AusinessException;
|
import com.gkhy.safePlatform.commons.exception.BusinessException;
|
import com.gkhy.safePlatform.commons.utils.BeanCopyUtils;
|
import com.gkhy.safePlatform.commons.utils.idService.SnowFlow;
|
import com.gkhy.safePlatform.commons.vo.ResultVO;
|
import com.gkhy.safePlatform.safeCheck.entity.*;
|
import com.gkhy.safePlatform.safeCheck.enums.DelectStatusEnum;
|
import com.gkhy.safePlatform.safeCheck.enums.UserTypeEnum;
|
import com.gkhy.safePlatform.safeCheck.model.dto.req.*;
|
import com.gkhy.safePlatform.safeCheck.model.dto.resp.*;
|
import com.gkhy.safePlatform.safeCheck.model.query.ListPointByPageDBQuery;
|
import com.gkhy.safePlatform.safeCheck.service.SafeCheckBaseManagerService;
|
import com.gkhy.safePlatform.safeCheck.service.SafeCheckMinioAccessService;
|
import com.gkhy.safePlatform.safeCheck.service.baseService.*;
|
import com.gkhy.safePlatform.safeCheck.util.UserInfoUtil;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.apache.dubbo.config.annotation.DubboReference;
|
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
|
@Service
|
public class SafeCheckBaseManagerServiceImpl implements SafeCheckBaseManagerService {
|
|
@DubboReference(check = false)
|
private AccountAuthService accountAuthService;
|
|
@DubboReference(check = false)
|
private AccountUserService accountUserService;
|
|
@DubboReference(check = false)
|
private AccountDepartmentService accountDepartmentService;
|
|
@Autowired
|
private RedissonClient redissonClient;
|
|
@Autowired
|
private SafeCheckQuotaTypeService safeCheckQuotaTypeService;
|
|
@Autowired
|
private SafeCheckRegionTypeService safeCheckRegionTypeService;
|
|
@Autowired
|
private SafeCheckPointService safeCheckPointService;
|
|
@Autowired
|
private SafeCheckRegionService safeCheckRegionService;
|
|
@Autowired
|
private SafeCheckMinioAccessService safeCheckMinioAccessService;
|
|
@Autowired
|
private SafeCheckQuotaService safeCheckQuotaService;
|
|
@Autowired
|
private SafeCheckUnitAndQuotaService safeCheckUnitAndQuotaService;
|
|
@Autowired
|
private SafeCheckRfidService safeCheckRfidService;
|
|
/**
|
* @description ***************************************** 通用的 **********************************************
|
*/
|
|
/**
|
* @description 获取巡检指标的单元及类型(有效状态)
|
*/
|
@Override
|
public List<SafeCheckQuotaTypeRespDTO> listQuotaType() {
|
List<SafeCheckQuotaTypeRespDTO> safeCheckQuotaTypeRespDTOS = new ArrayList<>();
|
List<SafeCheckQuotaType> quotaTypes = safeCheckQuotaTypeService.listQuotaType(DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (quotaTypes == null || quotaTypes.size() == 0 ){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"数据库不存在单元及类型，请添加");
|
}
|
safeCheckQuotaTypeRespDTOS = quotaTypes.stream().map((quotatype) -> {
|
SafeCheckQuotaTypeRespDTO safeCheckQuotaTypeRespDTO = new SafeCheckQuotaTypeRespDTO();
|
BeanUtils.copyProperties(quotatype, safeCheckQuotaTypeRespDTO);
|
return safeCheckQuotaTypeRespDTO;
|
}).collect(Collectors.toList());
|
return safeCheckQuotaTypeRespDTOS;
|
}
|
|
/**
|
* @description 获取巡检区域类型(有效状态)
|
*/
|
@Override
|
public List<SafeCheckRegionTypeRespDTO> listRegionType() {
|
List<SafeCheckRegionTypeRespDTO> safeCheckRegionTypeRespDTOS = new ArrayList<>();
|
List<SafeCheckRegionType> regionTypes = safeCheckRegionTypeService.listRegionType(DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (regionTypes == null || regionTypes.size() == 0 ){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"数据库不存在相关类型，请添加");
|
}
|
safeCheckRegionTypeRespDTOS = regionTypes.stream().map((regiontype) -> {
|
SafeCheckRegionTypeRespDTO safeCheckRegionTypeRespDTO = new SafeCheckRegionTypeRespDTO();
|
BeanUtils.copyProperties(regiontype, safeCheckRegionTypeRespDTO);
|
return safeCheckRegionTypeRespDTO;
|
}).collect(Collectors.toList());
|
return safeCheckRegionTypeRespDTOS;
|
}
|
|
/**
|
* @description 获取所有巡检区域名称(有效状态)
|
*/
|
@Override
|
public List<SafeCheckRegionNameRespDTO> listRegionName() {
|
List<SafeCheckRegionNameRespDTO> regionNameRespDTOS = new ArrayList<>();
|
List<SafeCheckRegion> regions = safeCheckRegionService.listRegionName(DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (regions == null || regions.size() == 0){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请新增巡检区域");
|
}
|
regionNameRespDTOS = regions.stream().map((region) ->{
|
SafeCheckRegionNameRespDTO regionNameRespDTO = new SafeCheckRegionNameRespDTO();
|
BeanUtils.copyProperties(region,regionNameRespDTO);
|
return regionNameRespDTO;
|
}).collect(Collectors.toList());
|
return regionNameRespDTOS;
|
}
|
|
/**
|
* @description 获取所有有效的RFID名称(有效状态)
|
*/
|
@Override
|
public List<SafeCheckRfidNameRespDTO> listRfidName() {
|
List<SafeCheckRfidNameRespDTO> rfidNameRespDTOS = new ArrayList<>();
|
List<SafeCheckRfid> rfids = safeCheckRfidService.listRfidName(DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (rfids == null || rfids.size() == 0){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请新增RFID");
|
}
|
rfidNameRespDTOS = rfids.stream().map((rfid) ->{
|
SafeCheckRfidNameRespDTO rfidNameRespDTO = new SafeCheckRfidNameRespDTO();
|
BeanUtils.copyProperties(rfid,rfidNameRespDTO);
|
return rfidNameRespDTO;
|
}).collect(Collectors.toList());
|
return rfidNameRespDTOS;
|
}
|
|
|
/**
|
* @description ***************************************** 巡检区域 **********************************************
|
*/
|
|
|
/**
|
* @description 新增巡检区域
|
*/
|
@Transactional
|
@Override
|
public int saveRegion(ContextCacheUser currentUser, SafeCheckRegionReqDTO safeCheckRegionReqDTO) {
|
SafeCheckRegion safeCheckRegion = new SafeCheckRegion();
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
if (safeCheckRegionReqDTO == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"关键参数不能为空");
|
}
|
String regionName = safeCheckRegionReqDTO.getRegion();
|
int regionTypeId = safeCheckRegionReqDTO.getRegionTypeId();
|
|
if (regionName == null || regionName.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域名称不能为空");
|
}
|
if (regionTypeId == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域类型不能为空");
|
}
|
if (safeCheckRegionReqDTO.getRegionDepartmentId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域所属部门不能为空");
|
}
|
//部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(safeCheckRegionReqDTO.getRegionDepartmentId());
|
if (depInfoByDepId.getData() == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"设备区域所属部门不存在");
|
}
|
//0、加分布式锁
|
String lockName = "SAFECHECK_REGION_CREATE_"+regionName;
|
RLock createRegionLock = redissonClient.getLock(lockName);
|
createRegionLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckRegion regionByName = safeCheckRegionService.getRegionByName(regionName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (regionByName != null){
|
throw new AusinessException(E.DATA_DATABASE_EXIST,"设备区域名称已经存在");
|
}
|
String regionTypeName = safeCheckRegionTypeService.getRegionTypeNameById(regionTypeId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
//雪花算法生成id和uuid
|
SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
|
String uuid = UUID.randomUUID().toString();
|
Date date = new Date();
|
long regionid = snowFlow.nextId();
|
|
safeCheckRegion.setId(regionid);
|
safeCheckRegion.setUuid(uuid);
|
safeCheckRegion.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
|
safeCheckRegion.setRegionDepartmentId(safeCheckRegionReqDTO.getRegionDepartmentId());
|
safeCheckRegion.setRegion(regionName);
|
safeCheckRegion.setRegionType(regionTypeName);
|
safeCheckRegion.setGmtCreate(date);
|
safeCheckRegion.setGmtModitify(date);
|
safeCheckRegion.setDepId(userInfo.getDepartment().getDepId());
|
safeCheckRegion.setDepUuid(null);
|
safeCheckRegion.setEnterpriseId(userInfo.getEnterprise().getId());
|
safeCheckRegion.setEnterpriseUuid(userInfo.getEnterprise().getUuid());
|
safeCheckRegion.setCreateByUserName(userInfo.getRealName());
|
safeCheckRegion.setLastEditUserName(userInfo.getRealName());
|
|
int saveResult = safeCheckRegionService.saveRegion(safeCheckRegion);
|
|
//释放分布式锁
|
createRegionLock.unlock();
|
return saveResult;
|
}
|
|
/**
|
* @description 根据id删除巡检区域
|
*/
|
@Transactional
|
@Override
|
public int deleteRegionById(ContextCacheUser currentUser, Long id) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
SafeCheckRegion region = this.paramIsValidAndRegionIsExit(id);
|
region.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
|
region.setGmtModitify(new Date());
|
region.setLastEditUserName(userInfo.getRealName());
|
int deleteResult = safeCheckRegionService.deleteRegionById(region,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
return deleteResult;
|
|
}
|
|
/**
|
* @description 根据id更新巡检区域
|
*/
|
@Transactional
|
@Override
|
public void updateRegionById(ContextCacheUser currentUser, SafeCheckRegionReqDTO safeCheckRegionReqDTO) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
if (safeCheckRegionReqDTO == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"关键参数不能为空");
|
}
|
String newRegionName = safeCheckRegionReqDTO.getRegion();
|
int newRegionTypeId = safeCheckRegionReqDTO.getRegionTypeId();
|
|
if (newRegionName == null || newRegionName.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域名称不能为空");
|
}
|
if (newRegionTypeId == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域类型不能为空");
|
}
|
if (safeCheckRegionReqDTO.getRegionDepartmentId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"设备区域所属部门不能为空");
|
}
|
//部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(safeCheckRegionReqDTO.getRegionDepartmentId());
|
if (depInfoByDepId.getData() == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"设备区域所属部门不存在");
|
}
|
SafeCheckRegion oldRegion = this.paramIsValidAndRegionIsExit(safeCheckRegionReqDTO.getId());
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_REGION_UPDATE_"+newRegionName;
|
RLock updateRegionLock = redissonClient.getLock(lockName);
|
updateRegionLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckRegion regionByName = safeCheckRegionService.getRegionByName(newRegionName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (regionByName != null){
|
if (!newRegionName.equals(oldRegion.getRegion())) {
|
throw new AusinessException(E.DATA_DATABASE_EXIST, "设备区域名称已存在");
|
}
|
}
|
String regionTypeName = safeCheckRegionTypeService.getRegionTypeNameById(safeCheckRegionReqDTO.getRegionTypeId()
|
,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
BeanUtils.copyProperties(safeCheckRegionReqDTO,oldRegion);
|
|
|
oldRegion.setRegionType(regionTypeName);
|
oldRegion.setGmtModitify(new Date());
|
oldRegion.setLastEditUserName(userInfo.getRealName());
|
safeCheckRegionService.updateRegionById(oldRegion,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
//1、释放分布式锁
|
updateRegionLock.unlock();
|
}
|
|
|
/**
|
* @description 根据巡检区域id、未删除标志查询巡检数据
|
*/
|
@Override
|
public SafeCheckRegionRespDTO getRegionById(Long id) {
|
SafeCheckRegionRespDTO safeCheckRegionRespDTO = new SafeCheckRegionRespDTO();
|
SafeCheckRegion safeCheckRegion = this.paramIsValidAndRegionIsExit(id);
|
String regionType = safeCheckRegion.getRegionType();
|
int regionTypeId = safeCheckRegionTypeService.getRegionTypeIdByName(regionType, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
BeanUtils.copyProperties(safeCheckRegion,safeCheckRegionRespDTO);
|
safeCheckRegionRespDTO.setRegionTypeId(regionTypeId);
|
return safeCheckRegionRespDTO;
|
}
|
|
|
/**
|
* @description 对区域id进行参数校验，以及数据库是否存在 存在即返回
|
*/
|
private SafeCheckRegion paramIsValidAndRegionIsExit(Long id){
|
//todo: 存在 应为 exist
|
if (id == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"巡检区域id不能为空");
|
}
|
SafeCheckRegion region = new SafeCheckRegion();
|
region = safeCheckRegionService.getOneRegion(id,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (region == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"该巡检区域数据库中不存在");
|
}
|
return region;
|
}
|
|
|
|
|
|
/**
|
* @description 条件分页查询所有的区域 没有条件就是全部查询
|
*/
|
@Override
|
public Page listRegionByPage(Page pageInfo, HashMap<String, Object> selectCondition,ContextCacheUser currentUser) {
|
int regionTypeId = (int) selectCondition.get("regionTypeId");
|
String regionTypeName = null;
|
if (regionTypeId != 1) {
|
regionTypeName = safeCheckRegionTypeService.getRegionTypeNameById(regionTypeId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (regionTypeName == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "巡检区域类型不存在");
|
}
|
}
|
selectCondition.put("regionTypeName",regionTypeName);
|
List<Long> depIds = null;
|
if (UserTypeEnum.STAFF.getCode() == currentUser.getType()){
|
ResultVO<List<Long>> resultVO = accountDepartmentService.listDepAndSubDepIds(currentUser.getDepId());
|
depIds = (List<Long>) resultVO.getData();
|
}
|
selectCondition.put("depIds",depIds);
|
|
Page pageInfoResult = safeCheckRegionService.listRegionByPage(pageInfo,selectCondition);
|
List<SafeCheckRegion> regions = pageInfoResult.getRecords();
|
if (regions == null && regions.size() == 0){
|
return null;
|
}
|
List<SafeCheckRegionPageRespDTO> regionPageRespDTOS = regions.stream().map((region)->{
|
SafeCheckRegionPageRespDTO regionPageRespDTO = new SafeCheckRegionPageRespDTO();
|
BeanUtils.copyProperties(region,regionPageRespDTO);
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(region.getDepId());
|
DepInfoRPCRespDTO depData = (DepInfoRPCRespDTO) depInfoByDepId.getData();
|
if (depData != null){
|
regionPageRespDTO.setRegionDepartment(depData.getDepName());
|
}
|
return regionPageRespDTO;
|
}).collect(Collectors.toList());
|
|
pageInfoResult.setRecords(regionPageRespDTOS);
|
|
return pageInfoResult;
|
}
|
|
/**
|
* @description ***************************************** 巡检指标 ********************************************
|
*/
|
|
/**
|
* @description 新增巡检指标
|
*/
|
@Transactional
|
@Override
|
public int saveQuota(ContextCacheUser currentUser, SafeCheckQuotaReqDTO safeCheckQuotaReqDTO) {
|
SafeCheckQuota safeCheckQuota = new SafeCheckQuota();
|
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
String quotaName = safeCheckQuotaReqDTO.getQuota();
|
|
if (quotaName == null){
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_QUOTA_CREATE_"+quotaName;
|
RLock createQuotaLock = redissonClient.getLock(lockName);
|
createQuotaLock.lock(3, TimeUnit.SECONDS);
|
|
if (safeCheckQuotaService.getQuotaByName(quotaName,DelectStatusEnum.DELECT_NO.getStatus()) != null){
|
throw new AusinessException(E.DATA_DATABASE_EXIST,"数据库已存在同名指标");
|
}
|
|
BeanUtils.copyProperties(safeCheckQuotaReqDTO,safeCheckQuota);
|
|
int quotaTypeId = safeCheckQuotaReqDTO.getQuotaTypeId();
|
String quotaType = safeCheckQuotaTypeService.getNameByTypeId(quotaTypeId);
|
if (quotaType == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"无此巡检指标类型");
|
}
|
|
safeCheckQuota.setQuotaType(quotaType);
|
safeCheckQuota.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
|
safeCheckQuota.setGmtCreate(new Date());
|
safeCheckQuota.setGmtModitify(new Date());
|
safeCheckQuota.setCreateUserName(userInfo.getRealName());
|
safeCheckQuota.setLastEditUserName(userInfo.getRealName());
|
|
int saveResult = safeCheckQuotaService.saveQuota(safeCheckQuota);
|
|
//释放分布式锁
|
createQuotaLock.unlock();
|
return saveResult;
|
|
}
|
|
|
/**
|
* @description 根据巡检指标id删除巡检指标
|
*/
|
@Transactional
|
@Override
|
public void deleteQuotaById(ContextCacheUser currentUser, Long quotaId) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
SafeCheckQuota quota = this.quotaIsExit(quotaId);
|
|
//判断巡检指标是否关联到其他任务单元
|
safeCheckUnitAndQuotaService.unitIsExitTheQuota(quotaId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
quota.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
|
quota.setGmtModitify(new Date());
|
quota.setLastEditUserName(userInfo.getRealName());
|
|
safeCheckQuotaService.deleteQuotaById(quota,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
}
|
|
/**
|
* @description 根据巡检指标id修改巡检指标
|
*
|
*/
|
@Transactional
|
@Override
|
public void updateQuotaById(ContextCacheUser currentUser, SafeCheckQuotaReqDTO safeCheckQuotaReqDTO) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
String quotaName = safeCheckQuotaReqDTO.getQuota();
|
|
if (quotaName.isEmpty()){
|
throw new AusinessException(E.DATA_PARAM_NULL,"巡检指标名不能为空");
|
}
|
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_QUOTA_UPDATE_"+quotaName;
|
RLock updateQuotaLock = redissonClient.getLock(lockName);
|
updateQuotaLock.lock(3, TimeUnit.SECONDS);
|
|
//判断修改后的指标名称是否存在
|
SafeCheckQuota quota = safeCheckQuotaService.getQuotaByName(quotaName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (quota != null ) {
|
if (quota.getId() != safeCheckQuotaReqDTO.getId()) {
|
throw new AusinessException(E.DATA_DATABASE_EXIST, "数据库已存在同名指标");
|
}
|
}
|
int quotaTypeId = safeCheckQuotaReqDTO.getQuotaTypeId();
|
String quotaType = safeCheckQuotaTypeService.getNameByTypeId(quotaTypeId);
|
if (quotaType == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"无此巡检指标类型");
|
}
|
|
SafeCheckQuota safeCheckQuota = this.quotaIsExit(safeCheckQuotaReqDTO.getId());
|
BeanUtils.copyProperties(safeCheckQuotaReqDTO,safeCheckQuota);
|
safeCheckQuota.setQuotaType(quotaType);
|
safeCheckQuota.setGmtModitify(new Date());
|
safeCheckQuota.setLastEditUserName(userInfo.getRealName());
|
|
safeCheckQuotaService.updateQuotaById(safeCheckQuota,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
|
//1、释放分布式锁
|
updateQuotaLock.unlock();
|
}
|
|
|
/**
|
* @description 根据巡检指标id获取巡检指标
|
*/
|
@Override
|
public SafeCheckQuotaUpdateRespDTO getQuataById(Long id) {
|
SafeCheckQuotaUpdateRespDTO safeCheckQuotaUpdateRespDTO = new SafeCheckQuotaUpdateRespDTO();
|
SafeCheckQuota safeCheckQuota = this.quotaIsExit(id);
|
BeanUtils.copyProperties(safeCheckQuota,safeCheckQuotaUpdateRespDTO);
|
int quotaTypeId = safeCheckQuotaTypeService.getTyIdByName(safeCheckQuota.getQuotaType());
|
safeCheckQuotaUpdateRespDTO.setQuotaTypeId(quotaTypeId);
|
return safeCheckQuotaUpdateRespDTO;
|
}
|
|
/**
|
* @description 根据巡检指标name获取巡检指标
|
*/
|
@Override
|
public SafeCheckQuotaRespDTO getQuotaByName(String quotaName) {
|
SafeCheckQuotaRespDTO safeCheckQuotaRespDTO = new SafeCheckQuotaRespDTO();
|
SafeCheckQuota safeCheckQuota = safeCheckQuotaService.getQuotaByName(quotaName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (safeCheckQuota == null){
|
return null;
|
};
|
BeanUtils.copyProperties(safeCheckQuota,safeCheckQuotaRespDTO);
|
return safeCheckQuotaRespDTO;
|
}
|
|
/**
|
* @description 分页获取当前页中的巡检指标信息
|
*/
|
@Override
|
public Page listQuotaByPage(Page pageInfo,String quotaName) {
|
List<SafeCheckQuotaRespDTO> safeCheckQuotaRespDTOS = new ArrayList<>();
|
Page pageInfoResult = safeCheckQuotaService.listQuotaByPage(pageInfo,quotaName);
|
List<SafeCheckQuota> quotas = pageInfoResult.getRecords();
|
if (quotas == null && quotas.size() == 0){
|
return null;
|
}
|
safeCheckQuotaRespDTOS = quotas.stream().map((quota)->{
|
SafeCheckQuotaRespDTO safeCheckQuotaRespDTO = new SafeCheckQuotaRespDTO();
|
BeanUtils.copyProperties(quota,safeCheckQuotaRespDTO);
|
return safeCheckQuotaRespDTO;
|
}).collect(Collectors.toList());
|
|
pageInfoResult.setRecords(safeCheckQuotaRespDTOS);
|
|
return pageInfoResult;
|
}
|
|
/**
|
* @description 判断巡检指标是否存在,存在则返回该指标
|
*/
|
private SafeCheckQuota quotaIsExit(Long quotaId){
|
SafeCheckQuota quota = safeCheckQuotaService.getQuotaById(quotaId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (quota == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"巡检指标不存在");
|
}
|
return quota;
|
}
|
|
/**
|
* @description ******************************************** rfid *************************************************
|
*/
|
|
/**
|
* @description 新增rfid
|
*
|
*/
|
@Transactional
|
@Override
|
public void saveRfid(ContextCacheUser currentUser, SafeCheckRfidReqDTO safeCheckRfidReqDTO) {
|
|
SafeCheckRfid safeCheckRfid = new SafeCheckRfid();
|
if (safeCheckRfid == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"关键参数不能为空");
|
}
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
//rfid编码
|
String rfid = safeCheckRfidReqDTO.getRfid();
|
String rfidName = safeCheckRfidReqDTO.getRfidName();
|
|
this.rfidParamIsValid(safeCheckRfidReqDTO);
|
|
BeanUtils.copyProperties(safeCheckRfidReqDTO,safeCheckRfid);
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_RFID_CREATE_"+rfidName;
|
RLock createRfidLock = redissonClient.getLock(lockName);
|
createRfidLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckRfid rfidByRfidName = safeCheckRfidService.getRfidByRfidName(rfidName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (rfidByRfidName != null){
|
throw new AusinessException(E.DATA_DATABASE_EXIST,"rfid名称已存在");
|
}
|
|
SafeCheckRfid safeCheckRfidByRfidName = safeCheckRfidService.getRfid(rfid,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (safeCheckRfidByRfidName != null){
|
throw new AusinessException(E.DATA_DATABASE_EXIST,"rfid编码已存在");
|
}
|
|
//初次新增默认有效状态
|
safeCheckRfid.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
|
safeCheckRfid.setGmtCreate(new Date());
|
safeCheckRfid.setCreateUserName(userInfo.getRealName());
|
safeCheckRfid.setGmtModitify(new Date());
|
safeCheckRfid.setLastEditUserName(userInfo.getRealName());
|
|
safeCheckRfidService.savaRfid(safeCheckRfid);
|
//释放分布式锁
|
createRfidLock.unlock();
|
}
|
|
/**
|
* @description 根据RFID的id值删除rfid
|
*/
|
@Transactional
|
@Override
|
public void deleteRfidById(ContextCacheUser currentUser, int rfidId) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
//先判断这个RFID是否存在
|
SafeCheckRfid safeCheckRfid = this.rfidIsExit(rfidId);
|
safeCheckRfid.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
|
safeCheckRfid.setGmtModitify(new Date());
|
safeCheckRfid.setLastEditUserName(userInfo.getRealName());
|
safeCheckRfidService.deleteRfidById(safeCheckRfid,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
}
|
|
/**
|
* @description 根据RFID的id更新RFID
|
*/
|
@Transactional
|
@Override
|
public void updateRfidById(ContextCacheUser currentUser, SafeCheckRfidReqDTO safeCheckRfidReqDTO) {
|
if (safeCheckRfidReqDTO == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "关键参数为空");
|
}
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
this.rfidParamIsValid(safeCheckRfidReqDTO);
|
//根据id获取到的数据库中的rfid
|
SafeCheckRfid rfidByRfidId = this.rfidIsExit(safeCheckRfidReqDTO.getId());
|
|
String rfidName = safeCheckRfidReqDTO.getRfidName();
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_RFID_UPDATE_"+rfidName;
|
RLock updateRfidLock = redissonClient.getLock(lockName);
|
updateRfidLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckRfid rfidByRfidName = safeCheckRfidService.getRfidByRfidName(rfidName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (rfidByRfidName != null){
|
if (!rfidName.equals(rfidByRfidId.getRfidName())) {
|
throw new AusinessException(E.DATA_DATABASE_EXIST, "rfid名称已存在");
|
}
|
}
|
|
//这是新改的rfid编码
|
String rfid = safeCheckRfidReqDTO.getRfid();
|
SafeCheckRfid safeCheckRfid = safeCheckRfidService.getRfid(rfid,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (safeCheckRfid != null){
|
if (!rfid.equals(rfidByRfidId.getRfid())) {
|
throw new AusinessException(E.DATA_DATABASE_EXIST, "rfid已关联其他设施区域");
|
}
|
}
|
if (safeCheckRfidReqDTO.getRfidImage() == null){
|
String rfidImage = rfidByRfidId.getRfidImage();
|
if (rfidImage != null){
|
safeCheckMinioAccessService.deleteFile(rfidImage);
|
}
|
BeanUtils.copyProperties(safeCheckRfidReqDTO, rfidByRfidId);
|
}else if (safeCheckRfidReqDTO.getRfidImage().startsWith("http")){
|
BeanUtils.copyProperties(safeCheckRfidReqDTO,rfidByRfidId,"rfidImage");
|
}else {
|
String rfidImage = rfidByRfidId.getRfidImage();
|
if (rfidImage != null){
|
safeCheckMinioAccessService.deleteFile(rfidImage);
|
}
|
BeanUtils.copyProperties(safeCheckRfidReqDTO, rfidByRfidId);
|
}
|
//初次新增默认有效状态
|
rfidByRfidId.setGmtModitify(new Date());
|
rfidByRfidId.setLastEditUserName(userInfo.getRealName());
|
safeCheckRfidService.updateRfidById(rfidByRfidId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
|
//1、释放分布式锁
|
updateRfidLock.unlock();
|
}
|
|
|
|
/**
|
* @description 校验更新和新增传来的参数是否有效
|
*/
|
private void rfidParamIsValid(SafeCheckRfidReqDTO safeCheckRfidReqDTO){
|
String rfidName = safeCheckRfidReqDTO.getRfidName();
|
|
String rfid = safeCheckRfidReqDTO.getRfid();
|
|
if (rfidName == null || rfidName.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"rfid名称不能为空");
|
}
|
|
if (rfid == null || rfid.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"rfid码不能为空");
|
}
|
if (safeCheckRfidReqDTO.getExceptionHandlerId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"rfid异常处理人不能为空");
|
}
|
if (safeCheckRfidReqDTO.getExceptionHandlerDepId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"rfid异常处理人所属部门不能为空");
|
}
|
if (safeCheckRfidReqDTO.getRfidDepartmentId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"rfid所属部门不能为空");
|
}
|
//获取异常处理人id 看是否存在
|
ResultVO<UserInfoRPCRespDTO> userInfoByUid = accountUserService.getUserInfoByUid(safeCheckRfidReqDTO.getExceptionHandlerId());
|
if (userInfoByUid.getData() == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"异常处置人不存在");
|
}
|
//部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(safeCheckRfidReqDTO.getRfidDepartmentId());
|
if (depInfoByDepId.getData() == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"rfid所属部门不存在");
|
}
|
}
|
|
|
/**
|
* @description 根据RFID的id值获取RFID
|
*/
|
@Override
|
public SafeCheckRfidRespDTO getRfidById(int rfidId) {
|
SafeCheckRfidRespDTO safeCheckRfidRespDTO = new SafeCheckRfidRespDTO();
|
SafeCheckRfid safeCheckRfid = this.rfidIsExit(rfidId);
|
BeanUtils.copyProperties(safeCheckRfid, safeCheckRfidRespDTO);
|
if (safeCheckRfid.getRfidImage() != null){
|
safeCheckRfidRespDTO.setRfidImage(safeCheckMinioAccessService.viewFile(safeCheckRfid.getRfidImage()));
|
};
|
return safeCheckRfidRespDTO;
|
}
|
|
|
/**
|
* @description 判断巡检RFID是否存在,存在则返回该RFID
|
*/
|
private SafeCheckRfid rfidIsExit(int rfidId){
|
SafeCheckRfid safeCheckRfid = safeCheckRfidService.getRfidById(rfidId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (safeCheckRfid == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"RFID不存在");
|
}
|
return safeCheckRfid;
|
}
|
|
/**
|
* @description 条件分页查询rfid 没有条件就是全部查询
|
*/
|
@Override
|
public Page listRfidByPage(Page pageInfo, SafeCheckRfidPageReqDTO safeCheckRfidPageReqDTO,ContextCacheUser currentUser) {
|
Byte type = currentUser.getType();
|
String rfidName = safeCheckRfidPageReqDTO.getRfidName();
|
String rfid = safeCheckRfidPageReqDTO.getRfid();
|
|
List<Long> depIds = null;
|
if (UserTypeEnum.STAFF.getCode() == type){
|
ResultVO<List<Long>> resultVO = accountDepartmentService.listDepAndSubDepIds(currentUser.getDepId());
|
depIds = (List<Long>) resultVO.getData();
|
}
|
Page pageInfoResult = safeCheckRfidService.listRfidByPage(pageInfo,rfidName,rfid,depIds);
|
|
List<SafeCheckRfid> safeCheckRfids = pageInfoResult.getRecords();
|
if (safeCheckRfids == null && safeCheckRfids.size() == 0){
|
return pageInfoResult;
|
}
|
List<SafeCheckRfidPageRepsDTO> safeCheckRfidPageRepsDTOS = safeCheckRfids.stream().map((safeCheckRfid)->{
|
SafeCheckRfidPageRepsDTO safeCheckRfidPageRepsDTO = new SafeCheckRfidPageRepsDTO();
|
BeanUtils.copyProperties(safeCheckRfid, safeCheckRfidPageRepsDTO);
|
|
ResultVO<UserInfoRPCRespDTO> userInfoByUid = accountUserService.getUserInfoByUid(safeCheckRfid.getExceptionHandlerId());
|
UserInfoRPCRespDTO userData = (UserInfoRPCRespDTO) userInfoByUid.getData();
|
if (userData != null){
|
safeCheckRfidPageRepsDTO.setExceptionHandler(userData.getRealName());
|
safeCheckRfidPageRepsDTO.setExceptionHandlerPhone(userData.getPhone());
|
}
|
//部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(safeCheckRfid.getRfidDepartmentId());
|
DepInfoRPCRespDTO depData = (DepInfoRPCRespDTO) depInfoByDepId.getData();
|
if (depData != null){
|
safeCheckRfidPageRepsDTO.setRfidDepartment(depData.getDepName());
|
}
|
if (safeCheckRfid.getRfidImage() != null){
|
safeCheckRfidPageRepsDTO.setRfidImage(safeCheckMinioAccessService.viewFile(safeCheckRfid.getRfidImage()));
|
}
|
return safeCheckRfidPageRepsDTO;
|
}).collect(Collectors.toList());
|
|
pageInfoResult.setRecords(safeCheckRfidPageRepsDTOS);
|
|
return pageInfoResult;
|
}
|
|
/**
|
* @description ******************************************** 巡检点 ************************************************
|
*/
|
|
|
/**
|
* @description 新增巡检点
|
*/
|
@Transactional
|
@Override
|
public void savePoint(ContextCacheUser currentUser, SafeCheckPointReqDTO safeCheckPointReqDTO) {
|
|
SafeCheckPoint safeCheckPoint = new SafeCheckPoint();
|
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
//rfid编码
|
String pointName = safeCheckPointReqDTO.getCode();
|
|
if (pointName == null || pointName.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"巡检点名称不能为空");
|
}
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_POINT_CREATE_"+pointName;
|
RLock createPointLock = redissonClient.getLock(lockName);
|
createPointLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckPoint safeCheckPointByName = safeCheckPointService.getPointByPointName(pointName,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (safeCheckPointByName != null){
|
throw new AusinessException(E.DATA_DATABASE_EXIST,"巡检点名称已存在");
|
}
|
BeanUtils.copyProperties(safeCheckPointReqDTO,safeCheckPoint);
|
|
//雪花算法生成id和uuid
|
SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
|
String uuid = UUID.randomUUID().toString();
|
long pointId = snowFlow.nextId();
|
|
//初次新增默认有效状态
|
safeCheckPoint.setId(pointId);
|
safeCheckPoint.setUuid(uuid);
|
safeCheckPoint.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
|
safeCheckPoint.setGmtCreate(new Date());
|
safeCheckPoint.setCreateUserName(userInfo.getRealName());
|
safeCheckPoint.setGmtModitify(new Date());
|
safeCheckPoint.setLastEditUserName(userInfo.getRealName());
|
safeCheckPoint.setEnterpriseId(userInfo.getEnterprise().getId());
|
safeCheckPoint.setEnterpriseUuid(userInfo.getEnterprise().getUuid());
|
|
safeCheckPointService.savePoint(safeCheckPoint);
|
|
//释放分布式锁
|
createPointLock.unlock();
|
}
|
|
/**
|
* @description 根据巡检点id删除巡检点
|
*/
|
@Transactional
|
@Override
|
public void deletePointById(ContextCacheUser currentUser, Long id) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
//先判断这个point是否存在
|
SafeCheckPoint safeCheckPoint = this.paramIsValidAndPointIsExit(id);
|
|
safeCheckPoint.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
|
safeCheckPoint.setGmtModitify(new Date());
|
safeCheckPoint.setLastEditUserName(userInfo.getRealName());
|
safeCheckPointService.deletePointById(safeCheckPoint,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
}
|
|
/**
|
* @description 根据巡检点id查询数据
|
*/
|
@Override
|
public SafeCheckPointRespDTO getPointById(Long id) {
|
SafeCheckPointRespDTO safeCheckPointRespDTO = new SafeCheckPointRespDTO();
|
SafeCheckPoint safeCheckPoint = this.paramIsValidAndPointIsExit(id);
|
BeanUtils.copyProperties(safeCheckPoint,safeCheckPointRespDTO);
|
return safeCheckPointRespDTO;
|
}
|
|
/**
|
* @description 根据id更新巡检点
|
*/
|
@Transactional
|
@Override
|
public void updatePointById(ContextCacheUser currentUser, SafeCheckPointReqDTO safeCheckPointReqDTO) {
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
|
UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
|
|
String newPointName = safeCheckPointReqDTO.getCode();
|
|
if (newPointName == null || newPointName.length() == 0){
|
throw new AusinessException(E.DATA_PARAM_NULL,"巡检点名称不能为空");
|
}
|
|
SafeCheckPoint oldPoint = this.paramIsValidAndPointIsExit(safeCheckPointReqDTO.getId());
|
|
//0、加分布式锁
|
String lockName = "SAFECHECK_POINT_UPDATE_"+newPointName;
|
RLock updatePointLock = redissonClient.getLock(lockName);
|
updatePointLock.lock(3, TimeUnit.SECONDS);
|
|
SafeCheckPoint pointByName = safeCheckPointService.getPointByPointName(newPointName, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
if (pointByName != null){
|
if (!newPointName.equals(oldPoint.getCode())) {
|
throw new AusinessException(E.DATA_DATABASE_EXIST, "巡检点名称已存在");
|
}
|
}
|
BeanUtils.copyProperties(safeCheckPointReqDTO,oldPoint);
|
|
oldPoint.setGmtModitify(new Date());
|
oldPoint.setLastEditUserName(userInfo.getRealName());
|
safeCheckPointService.updatePointById(oldPoint,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
|
//1、释放分布式锁
|
updatePointLock.unlock();
|
}
|
|
|
/**
|
* @description 对巡检点id进行参数校验，以及数据库是否存在 存在即返回
|
*/
|
private SafeCheckPoint paramIsValidAndPointIsExit(Long id){
|
|
if (id == null){
|
throw new AusinessException(E.DATA_PARAM_NULL,"巡检点id不能为空");
|
}
|
SafeCheckPoint point = new SafeCheckPoint();
|
point = safeCheckPointService.getOnePoint(id,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (point == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"该巡检点数据库中不存在");
|
}
|
return point;
|
}
|
|
/**
|
* @description 查询所有巡检点数据并进行分页展示
|
*/
|
@Override
|
public Page listPointByPage(Page pageInfo, SafeCheckPointPageReqDTO safeCheckPointPageReqDTO,ContextCacheUser currentUser) {
|
List<SafeCheckPointPageRespDTO> safeCheckPointPageRespDTOS;
|
String pointName = safeCheckPointPageReqDTO.getCode();
|
Long regionId = safeCheckPointPageReqDTO.getRegionId();
|
|
if (regionId == 1){
|
regionId = null;
|
}
|
ListPointByPageDBQuery pageDBQuery = new ListPointByPageDBQuery();
|
pageDBQuery.setPointName(pointName);
|
pageDBQuery.setRegionId(regionId);
|
List<Long> depIds = null;
|
if (UserTypeEnum.STAFF.getCode() == currentUser.getType()){
|
ResultVO<List<Long>> resultVO = accountDepartmentService.listDepAndSubDepIds(currentUser.getDepId());
|
depIds = (List<Long>) resultVO.getData();
|
}
|
pageDBQuery.setDepIds(depIds);
|
|
Page pageInfoResult = safeCheckPointService.listPointByPage(pageInfo,pageDBQuery);
|
|
|
List<SafeCheckPoint> points = pageInfoResult.getRecords();
|
if (CollectionUtils.isEmpty(points)){
|
return null;
|
}
|
safeCheckPointPageRespDTOS = points.stream().map((point)->{
|
SafeCheckPointPageRespDTO safeCheckPointPageRespDTO = new SafeCheckPointPageRespDTO();
|
BeanUtils.copyProperties(point,safeCheckPointPageRespDTO);
|
Long id = point.getRegionId();
|
int rfidId = point.getRfidId();
|
|
if (id != null) {
|
SafeCheckRegion region = safeCheckRegionService.getOneRegion(id,DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (region != null){
|
safeCheckPointPageRespDTO.setRegionName(region.getRegion());
|
}
|
}
|
|
if (rfidId != 0){
|
SafeCheckRfid rfid = safeCheckRfidService.getRfidById(rfidId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
|
if (rfid != null) {
|
safeCheckPointPageRespDTO.setRfidName(rfid.getRfidName());
|
}
|
}
|
return safeCheckPointPageRespDTO;
|
}).collect(Collectors.toList());
|
|
pageInfoResult.setRecords(safeCheckPointPageRespDTOS);
|
|
return pageInfoResult;
|
}
|
|
/**
|
* @description 获取所有巡检点、巡检区域、巡检rfid的id值
|
*/
|
@Override
|
public List<SafeCheckPointRespDTO> getPointRegionRfidId() {
|
List<SafeCheckPoint> points = safeCheckPointService.getPointRegionRfidId();
|
if (points == null){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"数据库无任何巡检点，请先新增巡检点");
|
}
|
List<SafeCheckPointRespDTO> pointRespDTOS = new ArrayList<>();
|
pointRespDTOS = points.stream().map((point)->{
|
SafeCheckPointRespDTO pointRespDTO = new SafeCheckPointRespDTO();
|
BeanUtils.copyProperties(point,pointRespDTO);
|
return pointRespDTO;
|
}).collect(Collectors.toList());
|
return pointRespDTOS;
|
}
|
|
/**
|
* 获取所有的巡检指标
|
*/
|
@Override
|
public List<ListQuotasRespDTO> listQuotas(ContextCacheUser currentUser) {
|
LambdaQueryWrapper<SafeCheckQuota> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(SafeCheckQuota::getDeleteStatus,DelectStatusEnum.DELECT_NO.getStatus());
|
List<SafeCheckQuota> quotas = safeCheckQuotaService.list(wrapper);
|
if (CollectionUtils.isEmpty(quotas)){
|
return null;
|
}
|
List<ListQuotasRespDTO> dtos = quotas.stream().map((quota) -> {
|
ListQuotasRespDTO dto = new ListQuotasRespDTO();
|
BeanUtils.copyProperties(quota, dto);
|
return dto;
|
}).collect(Collectors.toList());
|
return dtos;
|
}
|
}
|
