package com.moral.api.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.moral.api.config.mybatis.wrapper.NullFilterWrapper;
|
import com.moral.api.entity.*;
|
import com.moral.api.mapper.OrganizationUnitAlarmMapper;
|
import com.moral.api.mapper.SensorMapper;
|
import com.moral.api.mapper.VersionMapper;
|
import com.moral.api.mapper.VersionSensorUnitMapper;
|
import com.moral.api.pojo.dto.version.VersionDTO;
|
import com.moral.api.pojo.dto.version.VersionQueryDTO;
|
import com.moral.api.pojo.form.version.*;
|
import com.moral.api.service.VersionService;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.moral.api.util.CacheUtils;
|
import com.moral.constant.Constants;
|
import com.moral.constant.ResponseCodeEnum;
|
import com.moral.util.ConvertUtils;
|
import org.apache.tomcat.websocket.WsRemoteEndpointAsync;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
|
import java.util.*;
|
|
/**
|
* <p>
|
* 型号表 服务实现类
|
* </p>
|
*
|
* @author moral
|
* @since 2021-05-14
|
*/
|
@Service
|
public class VersionServiceImpl extends ServiceImpl<VersionMapper, Version> implements VersionService {
|
|
@Autowired
|
VersionMapper versionMapper;
|
@Autowired
|
VersionSensorUnitMapper versionSensorUnitMapper;
|
@Autowired
|
SensorMapper sensorMapper;
|
@Autowired
|
OrganizationUnitAlarmMapper organizationUnitAlarmMapper;
|
|
@Override
|
public VersionQueryDTO query(VersionQueryForm form) {
|
//创建返回对象
|
VersionQueryDTO dto = new VersionQueryDTO();
|
//取参
|
Integer page = form.getPage();
|
Integer size = form.getSize();
|
String name = form.getName();
|
Date createStartTime = form.getCreateStartTime();
|
Date createEndTime = form.getCreateEndTime();
|
Date updateStartTime = form.getUpdateStartTime();
|
Date updateEndTime = form.getUpdateEndTime();
|
String order = form.getOrder();
|
String orderType = form.getOrderType();
|
Integer isDelete = form.getIsDelete();
|
//组装查询条件
|
Page<Version> queryPage = new Page<>(page, size);
|
NullFilterWrapper<Version> wrapper = new NullFilterWrapper<>();
|
wrapper.like("name", name);
|
wrapper.between("create_time", createStartTime, createEndTime);
|
wrapper.between("update_time", updateStartTime, updateEndTime);
|
//排序顺序条件构造
|
if (!ObjectUtils.isEmpty(order) && !ObjectUtils.isEmpty(orderType)) {
|
if (orderType.equals(Constants.ORDER_ASC))
|
wrapper.orderByAsc(ConvertUtils.toLine(order));
|
else
|
wrapper.orderByDesc(ConvertUtils.toLine(order));
|
}
|
//逻辑删除条件构造
|
if (!ObjectUtils.isEmpty(isDelete))
|
wrapper.eq("is_delete", isDelete);
|
else
|
wrapper.eq("is_delete", Constants.NOT_DELETE);
|
//查询结果
|
Page<Version> versionsPage = versionMapper.selectPage(queryPage, wrapper);
|
List<Version> versions = versionsPage.getRecords();
|
//查询版本对应的因子和单位
|
List<Integer> versionsIds = new ArrayList<>();
|
versions.forEach(value -> versionsIds.add(value.getId()));
|
List<Version> queryResult = new ArrayList<>();
|
if (!ObjectUtils.isEmpty(versionsIds)) {
|
queryResult = versionMapper.queryVersionsAndSensorUnitByIds(versionsIds);
|
}
|
//封装返回数据
|
List<VersionDTO> dtos = new ArrayList<>();
|
queryResult.forEach(value -> dtos.add(new VersionDTO(value)));
|
dto.setVersionDTOS(dtos);
|
dto.setCurrent(versionsPage.getCurrent());
|
dto.setPages(versionsPage.getPages());
|
dto.setSize(versionsPage.getSize());
|
dto.setTotal(versionsPage.getTotal());
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
return dto;
|
}
|
|
@Override
|
@Transactional
|
public VersionDTO update(VersionUpdateForm form) {
|
//创建返回对象
|
VersionDTO dto = new VersionDTO();
|
//取参
|
Version version = form.formConvertEntity();
|
//查找要更新的version 用于插入日志
|
QueryWrapper<Version> oldVersionWrapper = new QueryWrapper<>();
|
Version oldVersion = new Version();
|
oldVersion.setId(version.getId());
|
oldVersion.setIsDelete(Constants.NOT_DELETE);
|
oldVersionWrapper.setEntity(oldVersion);
|
oldVersion = versionMapper.selectOne(oldVersionWrapper);
|
if (ObjectUtils.isEmpty(oldVersion)) {
|
dto.setCode(ResponseCodeEnum.VERSION_NOT_EXIST.getCode());
|
dto.setMsg(ResponseCodeEnum.VERSION_NOT_EXIST.getMsg());
|
return dto;
|
}
|
|
//更新
|
versionMapper.updateById(version);
|
|
//封装返回结果
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
|
return dto;
|
}
|
|
@Override
|
@Transactional
|
public VersionDTO insert(VersionInsertForm form) {
|
//创建返回对象
|
VersionDTO dto = new VersionDTO();
|
//取参
|
Version version = form.formConvertEntity();
|
//判断型号名称是否已经存在
|
Version existVersion = new Version();
|
existVersion.setName(version.getName());
|
existVersion.setIsDelete(Constants.NOT_DELETE);
|
QueryWrapper<Version> wrapper = new QueryWrapper<>();
|
wrapper.setEntity(existVersion);
|
Version existVersionResult = versionMapper.selectOne(wrapper);
|
if (!ObjectUtils.isEmpty(existVersionResult)) {
|
dto.setCode(ResponseCodeEnum.VERSION_EXIST.getCode());
|
dto.setMsg(ResponseCodeEnum.VERSION_EXIST.getMsg());
|
return dto;
|
}
|
//插入
|
versionMapper.insert(version);
|
//封装返回结果
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
return dto;
|
}
|
|
@Override
|
@Transactional
|
public VersionDTO delete(VersionDeleteForm form) {
|
//创建返回对象
|
VersionDTO dto = new VersionDTO();
|
//取参
|
Integer id = form.getId();
|
//查询型号是否被使用，如果被使用则无法删除
|
QueryWrapper<OrganizationUnitAlarm> queryWrapper = new QueryWrapper<>();
|
queryWrapper.select("id");
|
queryWrapper.eq("is_delete", Constants.NOT_DELETE);
|
queryWrapper.eq("version_id", id);
|
List<OrganizationUnitAlarm> organizationUnitAlarms = organizationUnitAlarmMapper.selectList(queryWrapper);
|
if (!ObjectUtils.isEmpty(organizationUnitAlarms)) {
|
dto.setCode(ResponseCodeEnum.VERSION_USED.getCode());
|
dto.setMsg(ResponseCodeEnum.VERSION_USED.getMsg());
|
return dto;
|
}
|
//查询要删除的版本用于记录日志
|
Version oldVersion = versionMapper.selectById(id);
|
//执行删除
|
Version deleteVersion = new Version();
|
deleteVersion.setId(oldVersion.getId());
|
deleteVersion.setIsDelete(Constants.DELETE);
|
versionMapper.updateById(deleteVersion);
|
//删除型号和因子单位对应表
|
UpdateWrapper deleteSensorUnitWrapper = new UpdateWrapper();
|
deleteSensorUnitWrapper.eq("version_id", id);
|
deleteSensorUnitWrapper.set("is_delete", Constants.DELETE);
|
versionSensorUnitMapper.update(null, deleteSensorUnitWrapper);
|
//封装返回结果
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
return dto;
|
}
|
|
@Override
|
@Transactional
|
public VersionDTO updateSensorUnits(VersionSensorUnitForm form) {
|
//创建返回对象
|
VersionDTO dto = new VersionDTO();
|
//取参
|
List<VersionSensorUnit> sensorUnits = form.getSensorUnits();
|
Integer versionId = form.getVersionId();
|
//将前端传来的id转为code
|
for (VersionSensorUnit sensorUnit : sensorUnits) {
|
Sensor sensor = sensorMapper.selectById(sensorUnit.getSensorId());
|
sensorUnit.setSensorCode(sensor.getCode());
|
}
|
//查询之前分配的单位和因子
|
QueryWrapper<VersionSensorUnit> queryOldWrapper = new QueryWrapper<>();
|
queryOldWrapper.eq("version_id", versionId);
|
queryOldWrapper.eq("is_delete", Constants.NOT_DELETE);
|
List<VersionSensorUnit> oldSensorUnits = versionSensorUnitMapper.selectList(queryOldWrapper);
|
//判断出变动的因子(要插入和要删除的)
|
List<VersionSensorUnit> insertList = new ArrayList<>();
|
List<VersionSensorUnit> deleteList = new ArrayList<>();
|
sensorUnits.forEach(value -> {
|
value.setVersionId(versionId);
|
if (!oldSensorUnits.contains(value))
|
insertList.add(value);
|
});
|
oldSensorUnits.forEach(value -> {
|
if (!sensorUnits.contains(value))
|
deleteList.add(value);
|
});
|
//删除记录
|
if (!ObjectUtils.isEmpty(deleteList)) {
|
UpdateWrapper deleteWrapper = new UpdateWrapper();
|
List<Integer> deleteIds = new ArrayList<>();
|
deleteList.forEach(value -> deleteIds.add(value.getId()));
|
deleteWrapper.in("id", deleteIds);
|
deleteWrapper.set("is_delete", Constants.DELETE);
|
versionSensorUnitMapper.update(null, deleteWrapper);
|
}
|
//添加记录
|
for (VersionSensorUnit sensorUnit : insertList) {
|
versionSensorUnitMapper.insert(sensorUnit);
|
}
|
//维护组织型号关系表
|
QueryWrapper<OrganizationUnitAlarm> queryOrgUnitAlarmWrapper = new QueryWrapper<>();
|
queryOrgUnitAlarmWrapper.select("distinct organization_id");
|
queryOrgUnitAlarmWrapper.eq("version_id", versionId);
|
queryOrgUnitAlarmWrapper.eq("is_delete", Constants.NOT_DELETE);
|
List<OrganizationUnitAlarm> organizationUnitAlarms = organizationUnitAlarmMapper.selectList(queryOrgUnitAlarmWrapper);
|
List<Integer> organizationIds = new ArrayList<>();
|
organizationUnitAlarms.forEach(value -> organizationIds.add(value.getOrganizationId()));
|
for (Integer organizationId : organizationIds) {
|
//删除因子
|
for (VersionSensorUnit versionSensorUnit : deleteList) {
|
UpdateWrapper deleteOrganizationUnitAlarmWrapper = new UpdateWrapper();
|
deleteOrganizationUnitAlarmWrapper.eq("organization_id", organizationId);
|
deleteOrganizationUnitAlarmWrapper.eq("version_id", versionId);
|
deleteOrganizationUnitAlarmWrapper.eq("sensor_code", versionSensorUnit.getSensorCode());
|
deleteOrganizationUnitAlarmWrapper.set("is_delete", Constants.DELETE);
|
organizationUnitAlarmMapper.update(null, deleteOrganizationUnitAlarmWrapper);
|
}
|
//新增因子
|
for (VersionSensorUnit versionSensorUnit : insertList) {
|
OrganizationUnitAlarm organizationUnitAlarm = new OrganizationUnitAlarm();
|
organizationUnitAlarm.setOrganizationId(organizationId);
|
organizationUnitAlarm.setVersionId(versionId);
|
organizationUnitAlarm.setSensorCode(versionSensorUnit.getSensorCode());
|
organizationUnitAlarm.setUnitKey(versionSensorUnit.getUnitKey());
|
organizationUnitAlarm.setShowUnitKey(versionSensorUnit.getUnitKey());
|
organizationUnitAlarmMapper.insert(organizationUnitAlarm);
|
}
|
}
|
//刷新deviceInfo缓存
|
CacheUtils.refreshDeviceAlarmInfo();
|
CacheUtils.refreshSpecialDeviceAlarmInfo();
|
//封装返回结果
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
return dto;
|
}
|
|
@Override
|
public VersionQueryDTO queryVersionById(VersionQueryByIdForm form) {
|
//创建返回对象
|
VersionQueryDTO dto = new VersionQueryDTO();
|
//取参
|
Integer id = form.getId();
|
Integer size = form.getSize();
|
Integer page = form.getPage();
|
//查询版本对应的因子和单位
|
List<Integer> versionsIds = new ArrayList<>();
|
versionsIds.add(id);
|
List<Version> versions = new ArrayList<>();
|
versions = versionMapper.queryVersionsAndSensorUnitByIds(versionsIds);
|
//根据分页信息进行选择因子
|
Version version = versions.get(0);
|
List<Sensor> querySensors = version.getSensors();
|
if (!ObjectUtils.isEmpty(querySensors)) {
|
int startIndex = (page - 1) * size;
|
int endIndex = startIndex + size - 1;
|
List<Sensor> resultSensors = new ArrayList<>();
|
|
for (int i = startIndex; i <= endIndex; i++) {
|
if (i >= querySensors.size())
|
break;
|
resultSensors.add(querySensors.get(i));
|
}
|
version.setSensors(resultSensors);
|
}
|
//封装返回对象
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
if (ObjectUtils.isEmpty(querySensors)) {
|
dto.setTotal(0);
|
dto.setPages(0);
|
} else {
|
dto.setTotal(querySensors.size());
|
double querySize = (double) querySensors.size();
|
double dSize = (double) size;
|
dto.setPages((int) Math.ceil(querySize / dSize));
|
}
|
dto.setSize(size);
|
dto.setCurrent(page);
|
VersionDTO versionDTO = new VersionDTO();
|
versionDTO.setVersion(version);
|
dto.setVersionDTOS(Arrays.asList(versionDTO));
|
return dto;
|
}
|
|
@Override
|
public VersionQueryDTO queryByOrganizationId(Integer organizationId) {
|
//创建返回对象
|
VersionQueryDTO dto = new VersionQueryDTO();
|
//查询型号id
|
QueryWrapper<OrganizationUnitAlarm> queryVersionIdsWrapper = new QueryWrapper<>();
|
queryVersionIdsWrapper.select("DISTINCT version_id").eq("is_delete", Constants.NOT_DELETE).eq("organization_id", organizationId);
|
List<OrganizationUnitAlarm> organizationUnitAlarms = organizationUnitAlarmMapper.selectList(queryVersionIdsWrapper);
|
List<Integer> versionIds = new ArrayList<>();
|
for (OrganizationUnitAlarm organizationUnitAlarm : organizationUnitAlarms) {
|
versionIds.add(organizationUnitAlarm.getVersionId());
|
}
|
//根据型号id查询型号
|
List<Version> versions = new ArrayList<>();
|
if (!ObjectUtils.isEmpty(versionIds))
|
versions = versionMapper.selectBatchIds(versionIds);
|
//封装返回对象
|
List<VersionDTO> versionDTOS = new ArrayList<>();
|
versions.forEach(value -> versionDTOS.add(new VersionDTO(value)));
|
dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
|
dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
|
dto.setVersionDTOS(versionDTOS);
|
return dto;
|
}
|
|
}
|
