package com.doumee.service.business.impl.collection;
|
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.doumee.core.constants.ResponseStatus;
|
|
import com.doumee.core.exception.BusinessException;
|
|
import com.doumee.core.haikang.isapi.IsapiClient;
|
|
import com.doumee.core.haikang.isapi.IsapiConstants;
|
|
import com.doumee.core.haikang.isapi.model.DeviceInfoDTO;
|
|
import com.doumee.core.haikang.isapi.model.DockDeviceDTO;
|
|
import com.doumee.core.haikang.isapi.model.DockStationBasicInfoDTO;
|
|
import com.doumee.core.haikang.isapi.model.StorageInfoDTO;
|
|
import com.doumee.core.utils.Constants;
|
|
import com.doumee.core.utils.IsapiHttpUtil;
|
|
import com.doumee.dao.business.CollectionDockDeviceMapper;
|
|
import com.doumee.dao.business.CollectionStationMapper;
|
|
import com.doumee.dao.business.model.CollectionDockDevice;
|
|
import com.doumee.dao.business.model.CollectionStation;
|
|
import com.doumee.service.business.CollectionStationService;
|
|
import com.doumee.service.business.third.model.LoginUserInfo;
|
|
import com.doumee.service.business.third.model.PageData;
|
|
import com.doumee.service.business.third.model.PageWrap;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import java.util.Date;
|
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
|
|
@Service
|
|
@Slf4j
|
|
public class CollectionStationServiceImpl implements CollectionStationService {
|
|
|
|
@Autowired
|
|
private CollectionStationMapper collectionStationMapper;
|
|
@Autowired
|
|
private CollectionDockDeviceMapper collectionDockDeviceMapper;
|
|
private final IsapiClient isapiClient = new IsapiClient();
|
|
|
|
@Override
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public Integer create(CollectionStation station) {
|
|
validateStation(station);
|
|
Date now = new Date();
|
|
station.setCreateDate(now);
|
|
station.setEditDate(now);
|
|
station.setIsdeleted(Constants.ZERO);
|
|
if (station.getStatus() == null) {
|
|
station.setStatus(Constants.ONE);
|
|
}
|
|
if (station.getPort() == null) {
|
|
station.setPort(defaultPort(station));
|
|
}
|
|
if (station.getUseHttps() == null) {
|
|
station.setUseHttps(Constants.ZERO);
|
|
}
|
|
if (StringUtils.isBlank(station.getModel())) {
|
|
station.setModel("UD39625B");
|
|
}
|
|
if (station.getLoginUserInfo() != null) {
|
|
station.setCreator(station.getLoginUserInfo().getUsername());
|
|
station.setEdirot(station.getLoginUserInfo().getUsername());
|
|
}
|
|
collectionStationMapper.insert(station);
|
|
return station.getId();
|
|
}
|
|
|
|
@Override
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void updateById(CollectionStation station) {
|
|
if (station.getId() == null) {
|
|
throw new BusinessException(ResponseStatus.BAD_REQUEST);
|
|
}
|
|
station.setEditDate(new Date());
|
|
if (station.getLoginUserInfo() != null) {
|
|
station.setEdirot(station.getLoginUserInfo().getUsername());
|
|
}
|
|
collectionStationMapper.updateById(station);
|
|
}
|
|
|
|
@Override
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void deleteById(Integer id, LoginUserInfo user) {
|
|
CollectionStation station = new CollectionStation();
|
|
station.setId(id);
|
|
station.setIsdeleted(Constants.ONE);
|
|
station.setEditDate(new Date());
|
|
if (user != null) {
|
|
station.setEdirot(user.getUsername());
|
|
}
|
|
collectionStationMapper.updateById(station);
|
|
}
|
|
|
|
@Override
|
|
@Transactional(rollbackFor = Exception.class)
|
|
public void deleteByIdInBatch(List<Integer> ids, LoginUserInfo user) {
|
|
if (ids == null) {
|
|
return;
|
|
}
|
|
for (Integer id : ids) {
|
|
deleteById(id, user);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public PageData<CollectionStation> findPage(PageWrap<CollectionStation> pageWrap) {
|
|
CollectionStation model = pageWrap.getModel() != null ? pageWrap.getModel() : new CollectionStation();
|
|
QueryWrapper<CollectionStation> wrapper = buildQueryWrapper(model);
|
|
IPage<CollectionStation> page = collectionStationMapper.selectPage(
|
new Page<>(pageWrap.getPage(), pageWrap.getCapacity()), wrapper);
|
return PageData.from(page);
|
}
|
|
|
|
@Override
|
|
public List<CollectionStation> findList(CollectionStation query) {
|
|
return collectionStationMapper.selectList(buildQueryWrapper(query != null ? query : new CollectionStation()));
|
|
}
|
|
|
|
@Override
|
|
public CollectionStation findById(Integer id) {
|
|
CollectionStation station = collectionStationMapper.selectById(id);
|
|
if (station == null || Constants.equalsInteger(station.getIsdeleted(), Constants.ONE)) {
|
|
throw new BusinessException(ResponseStatus.DATA_EMPTY);
|
|
}
|
|
return station;
|
|
}
|
|
|
|
@Override
|
|
public String syncAllStations() {
|
|
if (Constants.DEALING_HK_COLLECTION_STATION) {
|
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "采集站同步任务正在执行，请稍后");
|
|
}
|
|
Constants.DEALING_HK_COLLECTION_STATION = true;
|
|
try {
|
|
List<CollectionStation> list = collectionStationMapper.selectList(new QueryWrapper<CollectionStation>().lambda()
|
|
.eq(CollectionStation::getIsdeleted, Constants.ZERO)
|
|
.eq(CollectionStation::getStatus, Constants.ONE));
|
|
int success = 0;
|
|
int fail = 0;
|
|
for (CollectionStation station : list) {
|
|
try {
|
|
syncStationStatusInternal(station);
|
|
success++;
|
|
} catch (Exception e) {
|
|
fail++;
|
|
log.error("采集站同步失败 id={}: {}", station.getId(), e.getMessage());
|
|
}
|
|
}
|
|
return "同步完成：成功【" + success + "】台，失败【" + fail + "】台";
|
|
} finally {
|
|
Constants.DEALING_HK_COLLECTION_STATION = false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String syncStationStatus(Integer stationId) {
|
|
CollectionStation station = findById(stationId);
|
|
syncStationStatusInternal(station);
|
|
return "同步成功";
|
|
}
|
|
|
|
@Override
|
|
public String probeIsapi(Integer stationId) {
|
|
CollectionStation station = findById(stationId);
|
|
boolean https = station.getUseHttps() != null && station.getUseHttps() == 1;
|
|
String deviceInfo = IsapiHttpUtil.doGet(station.getIp(), station.getPort(), https,
|
|
station.getUsername(), station.getPassword(), IsapiConstants.DEVICE_INFO);
|
|
String storage = IsapiHttpUtil.doGet(station.getIp(), station.getPort(), https,
|
|
station.getUsername(), station.getPassword(), IsapiConstants.STORAGE);
|
|
String tracks = IsapiHttpUtil.doGet(station.getIp(), station.getPort(), https,
|
|
station.getUsername(), station.getPassword(), IsapiConstants.RECORD_TRACKS);
|
|
String dockBasic = IsapiHttpUtil.doGet(station.getIp(), station.getPort(), https,
|
|
station.getUsername(), station.getPassword(), IsapiConstants.DOCK_BASIC_INFO);
|
|
String dockDevices = IsapiHttpUtil.doGet(station.getIp(), station.getPort(), https,
|
|
station.getUsername(), station.getPassword(), IsapiConstants.DOCK_DEVICE_MANAGEMENT);
|
|
return "deviceInfo:\n" + StringUtils.defaultString(deviceInfo)
|
|
+ "\n\nstorage:\n" + StringUtils.defaultString(storage)
|
|
+ "\n\nrecord/tracks:\n" + StringUtils.defaultString(tracks)
|
|
+ "\n\ndockStation/basicInfo:\n" + StringUtils.defaultString(dockBasic)
|
|
+ "\n\ndockStation/deviceManagement:\n" + StringUtils.defaultString(dockDevices);
|
|
}
|
|
|
|
@Override
|
|
public List<CollectionDockDevice> findDockDevices(Integer stationId) {
|
|
findById(stationId);
|
|
return collectionDockDeviceMapper.selectList(new QueryWrapper<CollectionDockDevice>().lambda()
|
|
.eq(CollectionDockDevice::getStationId, stationId)
|
|
.eq(CollectionDockDevice::getIsdeleted, Constants.ZERO)
|
|
.orderByAsc(CollectionDockDevice::getId));
|
|
}
|
|
@Override
|
public PageData<CollectionDockDevice> findDockDevicePage(PageWrap<CollectionDockDevice> pageWrap) {
|
CollectionDockDevice model = pageWrap.getModel() != null ? pageWrap.getModel() : new CollectionDockDevice();
|
QueryWrapper<CollectionDockDevice> wrapper = new QueryWrapper<>();
|
wrapper.lambda()
|
.eq(CollectionDockDevice::getIsdeleted, Constants.ZERO)
|
.eq(model.getStationId() != null, CollectionDockDevice::getStationId, model.getStationId())
|
.like(StringUtils.isNotBlank(model.getDeviceName()), CollectionDockDevice::getDeviceName, model.getDeviceName())
|
.like(StringUtils.isNotBlank(model.getShortSerialNumber()), CollectionDockDevice::getShortSerialNumber, model.getShortSerialNumber())
|
.orderByDesc(CollectionDockDevice::getId);
|
IPage<CollectionDockDevice> page = collectionDockDeviceMapper.selectPage(
|
new Page<>(pageWrap.getPage(), pageWrap.getCapacity()), wrapper);
|
fillStationName(page.getRecords());
|
return PageData.from(page);
|
}
|
|
private void fillStationName(List<CollectionDockDevice> records) {
|
if (records == null || records.isEmpty()) {
|
return;
|
}
|
List<Integer> stationIds = records.stream()
|
.map(CollectionDockDevice::getStationId)
|
.filter(id -> id != null)
|
.distinct()
|
.collect(Collectors.toList());
|
if (stationIds.isEmpty()) {
|
return;
|
}
|
List<CollectionStation> stations = collectionStationMapper.selectBatchIds(stationIds);
|
Map<Integer, String> nameMap = stations.stream()
|
.collect(Collectors.toMap(CollectionStation::getId, CollectionStation::getName, (a, b) -> a));
|
records.forEach(row -> row.setStationName(nameMap.get(row.getStationId())));
|
}
|
|
|
|
private void syncStationStatusInternal(CollectionStation station) {
|
|
Date now = new Date();
|
|
CollectionStation update = new CollectionStation();
|
|
update.setId(station.getId());
|
|
update.setLastSyncTime(now);
|
|
update.setEditDate(now);
|
|
|
|
boolean online = isapiClient.isOnline(station);
|
|
update.setOnline(online ? Constants.ONE : Constants.ZERO);
|
|
|
|
if (online) {
|
|
DeviceInfoDTO deviceInfo = isapiClient.getDeviceInfo(station);
|
|
if (deviceInfo != null) {
|
|
if (StringUtils.isNotBlank(deviceInfo.getSerialNumber())) {
|
|
update.setSerialNo(deviceInfo.getSerialNumber());
|
|
}
|
|
if (StringUtils.isNotBlank(deviceInfo.getFirmwareVersion())) {
|
|
update.setSoftwareVersion(deviceInfo.getFirmwareVersion());
|
|
}
|
|
if (StringUtils.isBlank(station.getName()) && StringUtils.isNotBlank(deviceInfo.getDeviceName())) {
|
|
update.setName(deviceInfo.getDeviceName());
|
|
}
|
|
if (StringUtils.isNotBlank(deviceInfo.getModel())) {
|
|
update.setModel(deviceInfo.getModel());
|
|
}
|
|
}
|
|
DockStationBasicInfoDTO basicInfo = isapiClient.getDockBasicInfo(station);
|
|
if (basicInfo != null && StringUtils.isNotBlank(basicInfo.getDockStationId())
|
|
&& StringUtils.isBlank(station.getSerialNo())) {
|
|
update.setSerialNo(basicInfo.getDockStationId());
|
|
}
|
|
StorageInfoDTO storage = isapiClient.getStorageInfo(station);
|
|
if (storage != null) {
|
|
update.setTotalSpace(storage.getTotalSpaceGb());
|
|
update.setFreeSpace(storage.getFreeSpaceGb());
|
|
}
|
|
syncDockDevices(station.getId(), now);
|
|
}
|
|
collectionStationMapper.updateById(update);
|
|
}
|
|
|
|
private void syncDockDevices(Integer stationId, Date now) {
|
|
CollectionStation station = collectionStationMapper.selectById(stationId);
|
|
if (station == null) {
|
|
return;
|
|
}
|
|
List<DockDeviceDTO> devices = isapiClient.getDockDevices(station);
|
|
for (DockDeviceDTO src : devices) {
|
|
if (StringUtils.isBlank(src.getDeviceId())) {
|
|
continue;
|
|
}
|
|
CollectionDockDevice existed = collectionDockDeviceMapper.selectOne(new QueryWrapper<CollectionDockDevice>().lambda()
|
|
.eq(CollectionDockDevice::getStationId, stationId)
|
|
.eq(CollectionDockDevice::getDeviceId, src.getDeviceId())
|
|
.eq(CollectionDockDevice::getIsdeleted, Constants.ZERO));
|
|
if (existed == null) {
|
|
CollectionDockDevice row = new CollectionDockDevice();
|
|
row.setStationId(stationId);
|
|
row.setDeviceId(src.getDeviceId());
|
|
row.setDeviceName(src.getDeviceName());
|
|
row.setShortSerialNumber(src.getShortSerialNumber());
|
|
row.setAccessDeviceId(src.getAccessDeviceId());
|
|
row.setNetworkedDevice(Boolean.TRUE.equals(src.getNetworkedDevice()) ? Constants.ONE : Constants.ZERO);
|
|
row.setLastSyncTime(now);
|
|
row.setCreateDate(now);
|
|
row.setIsdeleted(Constants.ZERO);
|
|
collectionDockDeviceMapper.insert(row);
|
|
} else {
|
|
CollectionDockDevice row = new CollectionDockDevice();
|
|
row.setId(existed.getId());
|
|
row.setDeviceName(src.getDeviceName());
|
|
row.setShortSerialNumber(src.getShortSerialNumber());
|
|
row.setAccessDeviceId(src.getAccessDeviceId());
|
|
row.setNetworkedDevice(Boolean.TRUE.equals(src.getNetworkedDevice()) ? Constants.ONE : Constants.ZERO);
|
|
row.setLastSyncTime(now);
|
|
collectionDockDeviceMapper.updateById(row);
|
|
}
|
|
}
|
|
}
|
|
|
|
private QueryWrapper<CollectionStation> buildQueryWrapper(CollectionStation model) {
|
|
QueryWrapper<CollectionStation> wrapper = new QueryWrapper<>();
|
|
wrapper.lambda()
|
|
.eq(CollectionStation::getIsdeleted, Constants.ZERO)
|
|
.like(StringUtils.isNotBlank(model.getName()), CollectionStation::getName, model.getName())
|
|
.like(StringUtils.isNotBlank(model.getIp()), CollectionStation::getIp, model.getIp())
|
|
.eq(model.getOnline() != null, CollectionStation::getOnline, model.getOnline())
|
|
.eq(model.getStatus() != null, CollectionStation::getStatus, model.getStatus())
|
|
.orderByDesc(CollectionStation::getId);
|
|
return wrapper;
|
|
}
|
|
|
|
private void validateStation(CollectionStation station) {
|
|
if (StringUtils.isBlank(station.getIp()) || StringUtils.isBlank(station.getUsername())
|
|
|| StringUtils.isBlank(station.getPassword())) {
|
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "IP、用户名、密码不能为空");
|
|
}
|
|
}
|
|
|
|
private int defaultPort(CollectionStation station) {
|
|
if (station.getUseHttps() != null && station.getUseHttps() == 1) {
|
|
return 443;
|
|
}
|
|
return 80;
|
|
}
|
|
}
|
