package com.fzzy.igds.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.fzzy.igds.constant.Constant;
|
import com.fzzy.igds.constant.RedisConst;
|
import com.fzzy.igds.domain.DeviceSer;
|
import com.fzzy.igds.mapper.DeviceSerMapper;
|
import com.fzzy.igds.utils.ContextUtil;
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.common.core.redis.RedisCache;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.system.service.ISysDeptService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import javax.annotation.Resource;
|
import java.util.*;
|
|
/**
|
* @Description
|
* @Author CZT
|
* @Date 2025/11/28 13:48
|
*/
|
@Slf4j
|
@Service
|
public class DeviceSerService {
|
@Resource
|
private ISysDeptService iSysDeptService;
|
@Resource
|
private DeviceSerMapper deviceSerMapper;
|
@Resource
|
private RedisCache redisCache;
|
|
/**
|
* 根据条件查询分机信息
|
*
|
* @param companyId
|
* @param deptId
|
* @param parentId
|
* @return
|
*/
|
public List<DeviceSer> listDeviceSer(String companyId, String deptId, String parentId) {
|
|
QueryWrapper<DeviceSer> queryWrapper = new QueryWrapper<>();
|
|
if (StringUtils.isNotBlank(companyId)) {
|
queryWrapper.eq("company_id", companyId);
|
}
|
if (StringUtils.isNotBlank(deptId)) {
|
queryWrapper.eq("dept_id", deptId);
|
}
|
if (StringUtils.isNotBlank(parentId)) {
|
queryWrapper.likeRight("dept_id", parentId);
|
}
|
|
return deviceSerMapper.selectList(queryWrapper);
|
}
|
|
/**
|
* 查询分机列表
|
*
|
* @return
|
*/
|
public List<DeviceSer> getAllSer() {
|
SysUser user = ContextUtil.getLoginUser();
|
SysDept userDept = iSysDeptService.selectDeptById(user.getDeptId());
|
if (Constant.DEPT_TYPE_20.equals(userDept.getType())) {
|
return this.listDeviceSer(null, user.getDeptId() + "", null);
|
} else {
|
return this.listDeviceSer(null, null, user.getDeptId() + "");
|
}
|
}
|
|
|
/**
|
* 查询分机
|
*
|
* @param companyId
|
* @param id
|
* @return
|
*/
|
public DeviceSer getDataById(String companyId, String id) {
|
|
if (StringUtils.isEmpty(id)) {
|
return null;
|
}
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
|
QueryWrapper<DeviceSer> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("company_id", companyId);
|
queryWrapper.eq("id", id);
|
|
return deviceSerMapper.selectOne(queryWrapper);
|
}
|
|
/**
|
* 更新保存分机
|
*
|
* @param ser
|
*/
|
public void saveSer(DeviceSer ser) {
|
if (null == ser.getNetworkType()) {
|
ser.setNetworkType(Constant.NETWORK_01);
|
}
|
if (null == ser.getSn()) {
|
ser.setSn(ser.getId());
|
}
|
if (StringUtils.isEmpty(ser.getCompanyId())) {
|
ser.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(ser.getDeptId())) {
|
ser.setDeptId(ContextUtil.subDeptId(null));
|
}
|
if (StringUtils.isBlank(ser.getUpdateBy())) {
|
ser.setCreateBy(ContextUtil.getLoginUserName());
|
ser.setCreateTime(new Date());
|
ser.setUpdateBy(ContextUtil.getLoginUserName());
|
ser.setUpdateTime(new Date());
|
deviceSerMapper.insert(ser);
|
} else {
|
ser.setUpdateBy(ContextUtil.getLoginUserName());
|
ser.setUpdateTime(new Date());
|
deviceSerMapper.updateById(ser);
|
}
|
|
refreshCache(ser.getCompanyId());
|
}
|
|
/**
|
* 更新保存分机
|
*
|
* @param ser
|
*/
|
public void delSer(DeviceSer ser) {
|
deviceSerMapper.deleteById(ser);
|
|
//删除缓存
|
delCache(ser.getCompanyId(), ser.getId());
|
|
}
|
|
/**
|
* 更新分机信息
|
*
|
* @param status
|
* @param ip
|
* @param port
|
*/
|
public void updateStatusByIp(String status, String ip, Integer port) {
|
String companyId = ContextUtil.getCompanyId();
|
DeviceSer ser = this.getCacheSerByIp(companyId, ip);
|
|
ser.setStatus(status);
|
ser.setIp(ip);
|
ser.setPort(port);
|
ser.setUpdateTime(new Date());
|
|
deviceSerMapper.updateById(ser);
|
setCacheSer(ser);
|
}
|
|
/**
|
* 更新分机信息
|
*
|
* @param data
|
*/
|
public void updateByData(DeviceSer data) {
|
if (null == data) {
|
return;
|
}
|
DeviceSer ser = this.getCacheSer(data.getCompanyId(), data.getId());
|
if (null == ser) {
|
return;
|
}
|
ser.setStatus(Constant.YN_Y);
|
ser.setIp(data.getIp());
|
ser.setPort(data.getPort());
|
ser.setUpdateTime(new Date());
|
ser.setSn(data.getSn());
|
deviceSerMapper.updateById(ser);
|
|
setCacheSer(ser);
|
}
|
|
/**
|
* 更新分机信息
|
*
|
* @param companyId
|
* @param serId
|
* @param controlModel
|
*/
|
public void updateControlModel(String companyId, String serId, String controlModel) {
|
|
DeviceSer ser = this.getCacheSer(companyId, serId);
|
if (null == ser) {
|
return;
|
}
|
|
ser.setStatus(Constant.YN_Y);
|
ser.setControlModel(controlModel);
|
ser.setUpdateTime(new Date());
|
deviceSerMapper.updateById(ser);
|
|
setCacheSer(ser);
|
}
|
|
/**
|
* 刷新缓存
|
*
|
* @param companyId
|
*/
|
public void refreshCache(String companyId) {
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
List<DeviceSer> list = this.listDeviceSer(companyId, null, null);
|
this.setCacheSer(list, companyId);
|
}
|
|
/**
|
* 设置单个分机缓存
|
*
|
* @param ser
|
*/
|
public void setCacheSer(DeviceSer ser) {
|
if (null == ser) {
|
return;
|
}
|
ContextUtil.addSerCompany(ser.getSn(), ser.getCompanyId());
|
String key = RedisConst.buildKey(ser.getCompanyId(), RedisConst.KEY_DEVICE_SER_LIST, ser.getId());
|
redisCache.setCacheObject(key, ser);
|
}
|
|
/**
|
* 设置缓存
|
*
|
* @param data
|
* @param companyId
|
*/
|
public void setCacheSer(List<DeviceSer> data, String companyId) {
|
if (null == data) {
|
return;
|
}
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
String key;
|
for (DeviceSer ser : data) {
|
ContextUtil.addSerCompany(ser.getSn(), ser.getCompanyId());
|
key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, ser.getId());
|
redisCache.setCacheObject(key, ser);
|
}
|
}
|
|
/**
|
* 删除缓存信息
|
*
|
* @param companyId
|
* @param serId
|
*/
|
public void delCache(String companyId, String serId) {
|
if (StringUtils.isEmpty(serId)) {
|
return;
|
}
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, serId);
|
redisCache.deleteObject(key);
|
}
|
|
/**
|
* 根据组织编码获取分机列表
|
*
|
* @param companyId
|
* @return
|
*/
|
public List<DeviceSer> getCacheSerList(String companyId) {
|
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
String pattern = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST) + "*";
|
Collection<String> keys = redisCache.keys(pattern);
|
|
List<DeviceSer> result = new ArrayList<>();
|
if (null == keys) {
|
return result;
|
}
|
for (String key : keys) {
|
result.add((DeviceSer) redisCache.getCacheObject(key));
|
}
|
if (result.size() < 1) {
|
result = getAllSer();
|
}
|
if (result.size() < 1) {
|
return null;
|
}
|
//重新排序
|
Collections.sort(result, (p1, p2) -> p1.getOrderNum() - p2.getOrderNum());
|
return result;
|
}
|
|
/**
|
* 根据类型获取分机信息
|
*
|
* @param companyId
|
* @param type
|
* @return
|
*/
|
public List<DeviceSer> getSerCacheByType(String companyId, String type) {
|
List<DeviceSer> listAll = this.getCacheSerList(companyId);
|
if (null == listAll || listAll.isEmpty()) {
|
return null;
|
}
|
if (null == type) {
|
return listAll;
|
}
|
List<DeviceSer> result = new ArrayList<DeviceSer>();
|
for (DeviceSer ser : listAll) {
|
if (ser.getType().equals(type))
|
result.add(ser);
|
}
|
return result;
|
}
|
|
/**
|
* 根据分机ID获取分机信息
|
*
|
* @param companyId
|
* @param serId
|
* @return
|
*/
|
public DeviceSer getCacheSer(String companyId, String serId) {
|
if (StringUtils.isEmpty(serId)) {
|
return null;
|
}
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
String key = RedisConst.buildKey(companyId, RedisConst.KEY_DEVICE_SER_LIST, serId);
|
|
DeviceSer ser = (DeviceSer) redisCache.getCacheObject(key);
|
|
if (null == ser) {
|
ser = getDataById(companyId, serId);
|
if (null == ser) {
|
log.error("---------缓存中没有获取到分机缓存----------");
|
return null;
|
}
|
redisCache.setCacheObject(key, ser);
|
}
|
return ser;
|
}
|
|
/**
|
* 根据分机IP获取分机信息
|
*
|
* @param companyId
|
* @param ip
|
* @return
|
*/
|
public DeviceSer getCacheSerByIp(String companyId, String ip) {
|
if (StringUtils.isEmpty(companyId)) {
|
return null;
|
}
|
List<DeviceSer> serList = getCacheSerList(companyId);
|
if (null == serList) {
|
return null;
|
}
|
for (DeviceSer deviceSer : serList) {
|
if (deviceSer.getIp().equals(ip)) {
|
return deviceSer;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 根据分机IP和端口获取分机信息
|
*
|
* @param companyId
|
* @param ip
|
* @param port
|
* @return
|
*/
|
public DeviceSer getCacheSerByIp(String companyId, String ip, Integer port) {
|
if (StringUtils.isEmpty(companyId)) {
|
return null;
|
}
|
List<DeviceSer> serList = getCacheSerList(companyId);
|
if (null == serList) {
|
return null;
|
}
|
for (DeviceSer deviceSer : serList) {
|
if (deviceSer.getIp().equals(ip) && deviceSer.getPort() == port) {
|
return deviceSer;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 根据分机SN获取分机信息
|
*
|
* @param companyId
|
* @param sn
|
* @return
|
*/
|
public DeviceSer getCacheSerBySn(String companyId, String sn) {
|
|
if (StringUtils.isEmpty(companyId)) {
|
return null;
|
}
|
List<DeviceSer> serList = getCacheSerList(companyId);
|
if (null == serList) {
|
return null;
|
}
|
for (DeviceSer deviceSer : serList) {
|
if (deviceSer.getSn().equals(sn)) {
|
return deviceSer;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* -更新设备全部离线
|
*
|
* @param companyId
|
*/
|
public void allOffLine(String companyId) {
|
if (StringUtils.isEmpty(companyId)) {
|
companyId = ContextUtil.getCompanyId();
|
}
|
|
UpdateWrapper<DeviceSer> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.eq("company_id", companyId).set("status", Constant.YN_N);
|
deviceSerMapper.update(null, updateWrapper);
|
}
|
|
/**
|
* -根据SN更新状态
|
*
|
* @param ip
|
* @param port
|
* @param sn
|
* @param status
|
*/
|
public void onlineBySn(String ip, Integer port, String sn, String status) {
|
|
UpdateWrapper<DeviceSer> updateWrapper = new UpdateWrapper<>();
|
updateWrapper.eq("sn", sn).set("ip", ip).set("port", port).set("update_time", new Date());
|
deviceSerMapper.update(null, updateWrapper);
|
}
|
|
}
|
