package com.moral.service.impl;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import javax.annotation.Resource;
|
import javax.validation.constraints.NotNull;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.TypeReference;
|
import com.github.pagehelper.Page;
|
import com.github.pagehelper.PageHelper;
|
import com.moral.common.bean.Constants;
|
import com.moral.common.bean.PageBean;
|
import com.moral.common.bean.PageResult;
|
import com.moral.common.exception.BusinessException;
|
import com.moral.common.util.ExampleUtil;
|
import com.moral.common.util.RedisUtils;
|
import com.moral.common.util.ValidateUtil;
|
import com.moral.entity.Device;
|
import com.moral.entity.DeviceAndWind;
|
import com.moral.entity.DeviceProperty;
|
import com.moral.entity.MonitorPoint;
|
import com.moral.mapper.DeviceMapper;
|
import com.moral.mapper.DevicePropertyMapper;
|
import com.moral.mapper.DeviceVersionMapper;
|
import com.moral.mapper.DictionaryDataMapper;
|
import com.moral.mapper.MonitorPointMapper;
|
import com.moral.mapper.OrganizationMapper;
|
import com.moral.service.AccountService;
|
import com.moral.service.DeviceService;
|
import com.moral.service.MonitorPointService;
|
import com.moral.util.LatLngTransformation;
|
import com.moral.util.TkMybatisUtils;
|
|
import org.apache.commons.collections.MapUtils;
|
import org.apache.commons.lang3.BooleanUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.log4j.Logger;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
|
import tk.mybatis.mapper.entity.Example;
|
|
@Service
|
public class DeviceServiceImpl implements DeviceService {
|
private static Logger log = Logger.getLogger(DeviceServiceImpl.class);
|
//-----------------------redis key前缀-开始---------------------------------
|
private static String AlARM = "alarm";//警报阀值储存key前缀
|
private static String ADJUST = "adjust";//校准值存储key前缀
|
private static String DEVICE = "device";//设备信息数据key前缀
|
private static String STATE = "state";//设备实时状态key前缀
|
private static String DATA = "data";//设备实时数据key前缀
|
|
//-----------------------redis key前缀-结束---------------------------------
|
private String keysConnect(String... keys) {
|
StringBuilder key = new StringBuilder(keys[0]);
|
for (int i = 1; i < keys.length; i++) {
|
key.append("_");
|
key.append(keys[i]);
|
}
|
return key.toString().toLowerCase();
|
}
|
|
@Resource
|
private DeviceMapper deviceMapper;
|
@Resource
|
private MonitorPointMapper monitorPointMapper;
|
@Resource
|
private AccountService accountService;
|
private Class ENTITY_CLASS = Device.class;
|
@Resource
|
OrganizationMapper orgMapper;
|
@Resource
|
DeviceVersionMapper deviceVersionMapper;
|
@Resource
|
RedisUtils redisUtils;
|
@Resource
|
OrganizationMapper organizationMapper;
|
@Resource
|
DictionaryDataMapper dictionaryDataMapper;
|
@Resource
|
private MonitorPointService monitorPointService ;
|
|
@Override
|
public Map<String, Object> getDeviceStatesByAccount(Map<String, Object> parameters) {
|
ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");
|
Map<String, Object> result = new HashMap<String, Object>();
|
accountService.setOrgIdsByAccount(parameters);
|
List<Map<String, Object>> list = deviceMapper.getDeviceStatesByAccount(parameters);
|
Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
|
for (Map<String, Object> map : list) {
|
Long count = (Long) map.get("count");
|
all += count;
|
switch (Integer.valueOf((String) map.get("state"))) {
|
case 0:
|
normal = count;
|
break;
|
case 4:
|
stop = count;
|
break;
|
default:
|
abnormal += count;
|
}
|
}
|
result.put("all", all);
|
result.put("normal", normal);
|
result.put("abnormal", abnormal);
|
result.put("stop", stop);
|
return result;
|
}
|
|
@Override
|
@Transactional
|
public void saveOrUpdateDevice(Device device) {
|
ValidateUtil.notNull(device, "param.is.null");
|
ValidateUtil.notEmpty(device.getMac(), "param.is.null");
|
Device queryDevice = new Device();
|
queryDevice.setMac(device.getMac());
|
queryDevice = deviceMapper.selectOne(queryDevice);
|
Date operateDate = new Date();
|
device.setInstallTime(operateDate);
|
if (ObjectUtils.isEmpty(queryDevice)) {
|
device.setCreateTime(operateDate);
|
device.setState("4");
|
device.setIsDelete(Constants.IS_DELETE_FALSE);
|
deviceMapper.insertSelective(device);
|
} else {
|
device.setId(queryDevice.getId());
|
deviceMapper.updateByPrimaryKeySelective(device);
|
}
|
//刷新redis里的信息
|
refreshDeviceInRedis(device.getMac());
|
}
|
|
@Override
|
public List<Device> getInstallDevicesByOperateUser(Integer uid, Integer pageIndex, Integer pageSize) {
|
ValidateUtil.notNull(uid, "param.is.null");
|
Device device = new Device();
|
device.setOperateUserId(uid);
|
PageHelper.startPage(pageIndex, pageSize, false);
|
List<Device> devices = deviceMapper.select(device);
|
return devices;
|
}
|
|
/**
|
* @param mac
|
* @param fromCache
|
* @return 包含组织数组
|
*/
|
@Override
|
public Device getDeviceByMac(String mac, boolean fromCache) {
|
if (fromCache) {
|
Device device = getDeviceFromRedis(mac);
|
if (device == null) {
|
device = deviceMapper.selectWithOrgIdsByMac(mac);
|
}
|
return device;
|
} else {
|
return deviceMapper.selectWithOrgIdsByMac(mac);
|
}
|
|
}
|
|
/**
|
* 默认会从缓存取
|
*
|
* @param mac
|
* @return
|
*/
|
@Override
|
public Device getDeviceByMac(String mac) {
|
|
return getDeviceByMac(mac, true);
|
}
|
|
/*
|
* 获取报警阀值在redis里的key
|
*/
|
private String getDeviceKey(String mac) {
|
return keysConnect(DEVICE, mac);
|
}
|
|
// /*
|
// * 将校正值存入redis方法组 开始
|
// */
|
// private void setDeviceToRedis(String mac,Device device){
|
// String key = getDeviceKey(mac);
|
// Device simpleDevice = new Device();
|
// simpleDevice.setId(device.getId());// id
|
// simpleDevice.setName(device.getName());// name
|
// simpleDevice.setAddress(device.getAddress());// address
|
// simpleDevice.setDeviceVersionId(device.getDeviceVersionId());// version
|
// simpleDevice.setMac(device.getMac()); // mac
|
// simpleDevice.setMonitorPointId(device.getMonitorPointId());// 监控地id
|
// simpleDevice.setOrganizationIds(device.getOrganizationIds());// 组织数组
|
// simpleDevice.setDeviceVersion(device.getDeviceVersion());
|
// redisUtils.set(key,simpleDevice);
|
// }
|
private Device getDeviceFromRedis(String mac) {
|
String key = getDeviceKey(mac);
|
return redisUtils.get(key, Device.class);
|
}
|
|
/**
|
* @param params map里 包括 组织id和4个坐标点
|
* @return 返回未删除结果集
|
*/
|
@Override
|
public List<Device> query(Map<String, Object> params) {
|
List<Integer> dv = deviceMapper.getHasWindDirAndWindSpeedDeviceVersion();
|
Object orgIdObj = params.get("orgId");
|
String regionCode = params.get("regionCode").toString();
|
List<Device> deviceList = null;
|
if (orgIdObj != null) {
|
Integer orgId = Integer.parseInt(orgIdObj.toString());
|
List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
|
//剔除沧州地图页面非公司设备图标
|
if (regionCode.startsWith("1309")&&orgIdObj.toString().equals("5")) {
|
orgIds = new ArrayList<>();
|
Collections.addAll(orgIds, 60, 65, 159, 165, 166);
|
deviceList = deviceMapper.selectByMap(params);
|
Iterator<Device> iter = deviceList.iterator();
|
while (iter.hasNext()) {
|
Device device = iter.next();
|
Integer mpId = device.getMonitorPointId();
|
Integer oid = monitorPointService.byIdGetMonitorPoint(mpId).getOrganizationId();
|
if (!orgIds.contains(oid)) {
|
iter.remove();
|
} else {
|
if (orgId == 60) {
|
if (mpId != 56) {
|
iter.remove();
|
}
|
} else if (orgId == 65) {
|
if (mpId != 83 && mpId != 84) {
|
iter.remove();
|
}
|
}
|
}
|
}
|
}else {
|
params.put("orgIds", orgIds);
|
deviceList = deviceMapper.selectByMap(params);
|
}
|
// loadDeviceState(deviceList);
|
}
|
Example deviceExample = new Example(Device.class);//实例化
|
Example.Criteria deviceCriteria = deviceExample.createCriteria();
|
deviceCriteria.orEqualTo("isDelete", Constants.IS_DELETE_FALSE);
|
List<Device> devicesInfo = deviceMapper.selectByExample(deviceExample);
|
Example monitorExample = new Example(MonitorPoint.class);//实例化
|
Example.Criteria monitorCriteria = monitorExample.createCriteria();
|
monitorCriteria.orEqualTo("isDelete", Constants.IS_DELETE_FALSE);
|
List<MonitorPoint> monitorsInfo = monitorPointMapper.selectByExample(monitorExample);
|
for (Device d : deviceList) {
|
if (dv.contains(d.getDeviceVersionId())) {
|
d.setHasWindInfo(true);
|
} else {
|
d.setHasWindInfo(false);
|
}
|
for (Device temp : devicesInfo) {
|
if (d.getId().equals(temp.getId())) {
|
d.setState(temp.getState());
|
}
|
}
|
for (MonitorPoint mp : monitorsInfo) {
|
if (d.getMonitorPointId().equals(mp.getId())) {
|
d.setMonitorPoint(mp);
|
}
|
}
|
}
|
return deviceList;
|
}
|
|
/**
|
* 根据组织id和设备名称 分页查询设备
|
*
|
* @param orgId
|
* @param deviceName
|
* @param pageSize
|
* @param pageNo
|
* @return 返回未删除结果
|
*/
|
@Override
|
public PageResult query(Integer orgId, String deviceName, Integer pageSize, Integer pageNo) {
|
List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
|
if (!ObjectUtils.isEmpty(pageSize) && !ObjectUtils.isEmpty(pageNo)) {
|
PageHelper.startPage(pageNo, pageSize);
|
}
|
String state = null;
|
switch (deviceName) {
|
case "正常":
|
state = "0";
|
deviceName = null;
|
break;
|
case "轻度":
|
state = "1";
|
deviceName = null;
|
break;
|
case "中度":
|
state = "2";
|
deviceName = null;
|
break;
|
case "重度":
|
state = "3";
|
deviceName = null;
|
break;
|
case "维保":
|
state = "4";
|
deviceName = null;
|
break;
|
}
|
List<Device> list = deviceMapper.selectByOrgIdAndDevName(orgId, orgIds, state, deviceName);
|
//从redis里取状态
|
loadDeviceState(list);
|
if (list instanceof Page) {
|
return new PageResult(((Page) list).getTotal(), list);
|
}
|
return new PageResult(null, list);
|
}
|
|
/**
|
* 根据组织id和监控点id 分页查询设备
|
*
|
* @param orgId
|
* @param mpId
|
* @param pageSize
|
* @param pageNo
|
* @return 返回未删除结果
|
*/
|
@Override
|
public PageResult query(Integer orgId, Integer mpId, Integer pageSize, Integer pageNo) {
|
List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
|
if (!ObjectUtils.isEmpty(pageSize) && !ObjectUtils.isEmpty(pageNo)) {
|
PageHelper.startPage(pageNo, pageSize);
|
}
|
List<Device> list = deviceMapper.selectByOrgIdAndMpId(orgId, orgIds, mpId);
|
//从redis里取状态
|
loadDeviceState(list);
|
if (list instanceof Page) {
|
return new PageResult(((Page) list).getTotal(), list);
|
}
|
return new PageResult(null, list);
|
}
|
|
private void loadDeviceState(List<Device> list) {
|
//从redis里取状态
|
list.stream().map(device -> {
|
String mac = device.getMac();
|
if (!StringUtils.isBlank(mac)) {
|
String state = getSateFromRedis(device.getMonitorPointId(), mac.toLowerCase());
|
device.setState(state);
|
} else {
|
device.setState(Constants.DEVICE_STATE_OFFLINE);
|
}
|
return device;
|
}).count();
|
}
|
|
private String getSateFromRedis(Integer mpId, String mac) {
|
|
Map<String, String> stateMap = getStateMapFromRedis(mpId, mac);
|
String state = null;
|
if (stateMap != null) {
|
state = stateMap.get("state");
|
}
|
state = state == null ? Constants.DEVICE_STATE_OFFLINE : state;
|
return state;
|
}
|
|
public Map<String, String> getStateMapFromRedis(Integer mpId, String mac) {
|
StringBuilder key = new StringBuilder();
|
//拼凑key
|
key.append("state_").append(mpId).append("_").append(mac);
|
return redisUtils.get(key.toString(), new TypeReference<Map<String, String>>() {
|
});
|
}
|
|
private Device getDeviceWithOrgIdsByMac(String mac) {
|
String key = "device_" + mac;
|
Device device = redisUtils.get(key, Device.class);
|
if (device == null) {
|
device = deviceMapper.selectWithOrgIdsByMac(mac);
|
if (device != null) {
|
redisUtils.set(key, device);
|
}
|
}
|
return device;
|
}
|
|
/**
|
* 要在数据库更改后刷新
|
* 刷新 redis 设备的信息,注意此处指删除不做更新。更新由task完成
|
*
|
* @param mac
|
*/
|
private void refreshDeviceInRedis(String mac) {
|
if (!StringUtils.isBlank(mac)) {
|
String key = getDeviceKey(mac);
|
redisUtils.remove(key);
|
} else {
|
log.warn("param mac is null in method [refreshDeviceInRedis]");
|
}
|
}
|
|
@Override
|
public int countByExample(PageBean pageBean) {
|
Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
|
TkMybatisUtils.addDeletesToExample(example);
|
return deviceMapper.selectCountByExample(example);
|
}
|
|
@Override
|
public PageBean queryByPageBean(PageBean pageBean) {
|
Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
|
// addDeletesToExample(example);
|
if (pageBean.getPageSize() > 0) {
|
PageHelper.startPage(pageBean.getPageIndex(), pageBean.getPageSize());
|
}
|
List<Device> deviceList = deviceMapper.selectWithRelationData(example);
|
return new PageBean(deviceList);
|
}
|
|
@Override
|
public void deleteByIds(Integer[] ids) {
|
Device device = new Device();
|
device.setIsDelete(Constants.IS_DELETE_TRUE);
|
if (ids != null && ids.length > 0) {
|
Example example = new Example(ENTITY_CLASS);
|
example.or().andIn("id", Arrays.asList(ids));
|
if (ids.length == 1) {
|
device.setId(ids[0]);
|
deviceMapper.updateByPrimaryKeySelective(device);
|
} else {
|
deviceMapper.updateByExampleSelective(device, example);
|
}
|
List<Device> deviceList = deviceMapper.selectByExample(example);
|
List<String> adjustAndDeviceKeys = deviceList.stream().collect(
|
ArrayList<String>::new,
|
(list, dev) -> {
|
if (!StringUtils.isBlank(dev.getMac())) {
|
list.add("device_" + dev.getMac());
|
list.add("adjust_" + dev.getMac());
|
}
|
},
|
(oList, nList) -> {
|
oList.addAll(nList);
|
}
|
);
|
redisUtils.remove(adjustAndDeviceKeys.toArray(new String[adjustAndDeviceKeys.size()]));
|
}
|
}
|
|
@Override
|
@Transactional
|
public void addOrModify(Device device) {
|
try {
|
//mac 转小写
|
if (!StringUtils.isBlank(device.getMac())) {
|
device.setMac(device.getMac().toLowerCase());
|
}
|
if (device.getId() != null) {
|
deviceMapper.updateByPrimaryKeySelective(device);
|
} else {
|
Device deviceQuery = new Device();
|
deviceQuery.setMac(device.getMac());
|
Device deviceResult = deviceMapper.selectOne(deviceQuery);
|
if (deviceResult != null) {
|
device.setId(deviceResult.getId());
|
deviceMapper.updateByPrimaryKeySelective(device);
|
} else {
|
device.setState(Constants.DEVICE_STATE_OFFLINE);
|
device.setIsDelete(Constants.IS_DELETE_FALSE);
|
deviceMapper.insertSelective(device);
|
}
|
}
|
//刷新redis里设备信息
|
refreshDeviceInRedis(device.getMac());
|
} catch (Exception ex) {
|
throw ex;
|
}
|
}
|
|
@Override
|
public List<Map> countByTimes(Date start, Date end, String format) {
|
if (start == null || end == null || StringUtils.isBlank(format)) {
|
log.error("some params is null");
|
throw new BusinessException("some params is null");
|
}
|
return deviceMapper.countByTimes(start, end, format);
|
}
|
|
@Override
|
public List<Device> getDevicesByMonitorPointId(Integer monitorPointId) {
|
Device device = new Device();
|
device.setMonitorPointId(monitorPointId);
|
device.setIsDelete(Constants.IS_DELETE_FALSE);
|
List<Device> devices = deviceMapper.select(device);
|
for (Device device2 : devices) {
|
DeviceProperty deviceProperty = devicePropertyMapper.selectByPrimaryKey(device2.getId());
|
device2.setDeviceProperty(deviceProperty);
|
}
|
return devices;
|
}
|
|
/**
|
* 返回map{mac：，state：}
|
*
|
* @param macList
|
* @return
|
*/
|
@Override
|
public List<Map<String, String>> queryDevicesState(List<String> macList, Boolean withData) {
|
List<Map<String, String>> list = macList.stream().map(mac -> {
|
Map<String, String> resultMap = new HashMap<>();
|
if (!StringUtils.isBlank(mac)) {
|
mac = mac.toLowerCase();
|
Device device = getDeviceWithOrgIdsByMac(mac);
|
Map<String, String> stateMap = getStateMapFromRedis(device.getMonitorPointId(), mac);
|
if (!MapUtils.isEmpty(stateMap)) {
|
resultMap.putAll(stateMap);
|
} else {
|
resultMap.put("state", Constants.DEVICE_STATE_OFFLINE);
|
resultMap.put("mac", mac);
|
}
|
//添加data
|
if (BooleanUtils.isTrue(withData)) {
|
String dataKey = "data_" + mac;
|
Map<String, String> dataMap = redisUtils.get(dataKey, new TypeReference<Map<String, String>>() {
|
});
|
if (!MapUtils.isEmpty(dataMap)) {
|
resultMap.putAll(dataMap);
|
}
|
}
|
}
|
return resultMap;
|
}).collect(Collectors.toList());
|
return list;
|
}
|
|
@Override
|
public Device queryById(Integer id) {
|
return deviceMapper.selectByPrimaryKey(id);
|
}
|
|
@Override
|
public List<Device> getDevicesByProfessionId(Map<String, Object> parameters) {
|
|
return deviceMapper.getDevicesByProfession(parameters);
|
}
|
|
@Override
|
public List<Device> getDevicesByOrganizationId(Map<String, Object> parameters) {
|
ValidateUtil.notNull(parameters.get("organizationId"), "param.is.null");
|
return deviceMapper.getDevicesByOrganizationId(parameters);
|
}
|
|
@Override
|
public Map<String, Long> queryDeviceStateSummary(@NotNull Integer orgId) {
|
Map<String, Object> params = new HashMap<>();
|
if (!dictionaryDataMapper.isSupperOrgId(orgId)) {
|
List<Integer> orgIds = organizationMapper.selectLowerOrgIds(orgId);
|
params.put("orgIds", orgIds);
|
}
|
List<Map<String, Object>> list = deviceMapper.getDeviceStatesByAccount(params);
|
Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
|
for (Map<String, Object> map : list) {
|
Long count = (Long) map.get("count");
|
all += count;
|
switch (Integer.valueOf((String) map.get("state"))) {
|
case 0:
|
normal = count;
|
break;
|
case 4:
|
stop = count;
|
break;
|
default:
|
abnormal += count;
|
}
|
}
|
Map<String, Long> result = new HashMap<>();
|
result.put("all", all);
|
result.put("normal", normal);
|
result.put("abnormal", abnormal);
|
result.put("stop", stop);
|
return result;
|
}
|
|
@Resource
|
private DevicePropertyMapper devicePropertyMapper;
|
|
@Override
|
@Transactional
|
public void saveOrUpdate(Device device, DeviceProperty deviceProperty) {
|
device.setMac(device.getMac().toLowerCase());
|
if (ObjectUtils.isEmpty(device.getId())) {
|
device.setState(Constants.DEVICE_STATE_OFFLINE);
|
device.setIsDelete(Constants.IS_DELETE_FALSE);
|
deviceMapper.insertSelective(device);
|
deviceProperty.setId(device.getId());
|
} else {
|
deviceMapper.updateByPrimaryKeySelective(device);
|
devicePropertyMapper.deleteByPrimaryKey(deviceProperty);
|
}
|
devicePropertyMapper.insertSelective(deviceProperty);
|
refreshDeviceInRedis(device.getMac());
|
|
}
|
|
@Override
|
public PageBean getDeviceList(PageBean pageBean) {
|
Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
|
if (pageBean.getPageSize() > 0) {
|
PageHelper.startPage(pageBean.getPageIndex(), pageBean.getPageSize());
|
}
|
List<Device> deviceList = deviceMapper.getDeviceList(example);
|
return new PageBean(deviceList);
|
}
|
|
@Override
|
public void offLinToMaintenance(Map<String, Object> parameters) {
|
ValidateUtil.notNull(parameters.get("id"), "param.is.null");
|
ValidateUtil.notNull(parameters.get("old_state"), "param.is.null");
|
ValidateUtil.notNull(parameters.get("new_state"), "param.is.null");
|
int count = 0;
|
if (Constants.DEVICE_STATE_OFFLINE.equals(parameters.get("old_state")) && Constants.DEVICE_STATE_MAINTENANCE.equals(parameters.get("new_state"))) {
|
Device device = new Device();
|
Example example = new Example(ENTITY_CLASS);
|
example.and().andEqualTo("id", new Integer(parameters.get("id").toString())).andEqualTo("state", Constants.DEVICE_STATE_OFFLINE);
|
device.setState(Constants.DEVICE_STATE_MAINTENANCE);
|
count = deviceMapper.updateByExampleSelective(device, example);
|
}
|
if (count == 0) {
|
throw new BusinessException("参数不合法！");
|
}
|
}
|
|
@Override
|
public void saveOrUpdate4Mobile(Device device, DeviceProperty deviceProperty) {
|
device.setMac(device.getMac().toLowerCase());
|
Device selectDevice = new Device();
|
selectDevice.setMac(device.getMac());
|
selectDevice = deviceMapper.selectOne(selectDevice);
|
if (ObjectUtils.isEmpty(selectDevice)) {
|
device.setState(Constants.DEVICE_STATE_OFFLINE);
|
device.setIsDelete(Constants.IS_DELETE_FALSE);
|
deviceMapper.insertSelective(device);
|
deviceProperty.setId(device.getId());
|
devicePropertyMapper.insertSelective(deviceProperty);
|
} else {
|
device.setId(selectDevice.getId());
|
deviceMapper.updateByPrimaryKeySelective(device);
|
deviceProperty.setId(selectDevice.getId());
|
devicePropertyMapper.selectByPrimaryKey(selectDevice.getId());
|
if (ObjectUtils.isEmpty(devicePropertyMapper.selectByPrimaryKey(deviceProperty.getId()))) {
|
devicePropertyMapper.insertSelective(deviceProperty);
|
} else {
|
devicePropertyMapper.updateByPrimaryKeySelective(deviceProperty);
|
}
|
|
}
|
refreshDeviceInRedis(device.getMac());
|
|
|
}
|
|
@Override
|
public String getLimitDataByDevice(Map<String, Object> parameters) {
|
// TODO Auto-generated method stub
|
return deviceMapper.getLimitDataByDevice(parameters);
|
}
|
|
//按经度升序排序，通过mac地址找到相邻经度的第二个点位置
|
@Override
|
public Device getDeviceByLongitudeAsc(String mac) {
|
Example example = new Example(Device.class);
|
example.setOrderByClause("longitude ASC");
|
List<Device> deviceList = deviceMapper.selectByExample(example);
|
for (int i = 0; i < deviceList.size(); i++) {
|
if (mac.equals(deviceList.get(i).getMac())) {
|
Device deviceSecond = deviceList.get(i + 1);
|
return deviceSecond;
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public List<String> getMacsByOrganizationId(List<Object> organizationIdList) {
|
return deviceMapper.getMacsByOrganizationId(organizationIdList);
|
}
|
|
@Override
|
public List<Device> getDeviceById1(int id) {
|
return deviceMapper.getDeviceById1(id);
|
}
|
|
@Override
|
public List<Device> getDeviceById2(int id) {
|
return deviceMapper.getDeviceById2(id);
|
}
|
|
@Override
|
public List<Device> getDeviceById3(int id) {
|
return deviceMapper.getDeviceById3(id);
|
}
|
|
@Override
|
public List<Device> queryDevice(Map<String, Object> params) {
|
List<Integer> dv = deviceMapper.getHasWindDirAndWindSpeedDeviceVersion();
|
Object orgIdObj = params.get("orgId");
|
List<Device> deviceList = null;
|
if (orgIdObj != null) {
|
Integer orgId = Integer.parseInt(orgIdObj.toString());
|
List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
|
params.put("orgIds", orgIds);
|
deviceList = deviceMapper.selectDevicesAll(params);
|
}
|
List<Device> deviceListHasWind = new ArrayList<>();
|
for (Device d : deviceList) {
|
if (dv.contains(d.getDeviceVersionId())) {
|
deviceListHasWind.add(d);
|
}
|
}
|
return deviceListHasWind;
|
}
|
|
@Override
|
public Map<String, Object> getAllFieldByMac(Map<String, Object> parameters) {
|
Map<String, Object> deviceMap = deviceMapper.selectAllFieldByMac(parameters);
|
return deviceMap;
|
}
|
|
@Override
|
public List<DeviceAndWind> getAllDevice() {
|
return deviceMapper.getAllDevice();
|
}
|
|
@Override
|
public List<String> getAllMac() {
|
return deviceMapper.getAllMac();
|
}
|
|
@Override
|
public Device byMacGetDevice(String mac) {
|
return deviceMapper.byMacGetDevice(mac);
|
}
|
|
@Override
|
public List byMonitorIdGetDeviceAndWind(String id, String tab) {
|
List<DeviceAndWind> deviceAndWinds = deviceMapper.byMonitorIdGetDeviceAndWind(Integer.parseInt(id), tab);
|
System.out.println(deviceAndWinds);
|
System.out.println(deviceAndWinds);
|
List loList = new ArrayList();
|
List laList = new ArrayList();
|
Double U = 0.0;
|
Double V = 0.0;
|
List list = new ArrayList();
|
for (DeviceAndWind andWind : deviceAndWinds) {
|
Double lo = andWind.getLongitude();
|
Double la = andWind.getLatitude();
|
List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(la, lo);
|
Double transLo = (Double) tranlist.get(0);
|
Double transLa = (Double) tranlist.get(1);
|
loList.add(transLo);
|
laList.add(transLa);
|
}
|
Double loma = 0.0;
|
Double lomi = 0.0;
|
Double lama = 0.0;
|
Double lami = 0.0;
|
if (loList.size() > 0) {
|
loma = (Double) Collections.max(loList);
|
lomi = (Double) Collections.min(loList);
|
}
|
if (laList.size() > 0) {
|
lama = (Double) Collections.max(laList);
|
lami = (Double) Collections.min(laList);
|
}
|
Map laLaMap = new HashMap();
|
laLaMap.put("maxLo", loma);
|
laLaMap.put("minLo", lomi);
|
laLaMap.put("maxLa", lama);
|
laLaMap.put("minLa", lami);
|
|
Double lo1 = lomi - 250 * 0.00001141;
|
Double lo2 = loma + 250 * 0.00001141;
|
Double la2 = lami - 250 * 0.00000899;
|
Double la1 = lama + 250 * 0.00000899;
|
|
Double dx = 0.00001141 * 20;
|
Double dy = 0.00000899 * 20;
|
int nx = (int) Math.floor((lo2 - lo1) / dx);
|
int ny = (int) Math.floor((la1 - la2) / dy);
|
String header1 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 2 +
|
", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
|
", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
|
", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
|
", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";
|
|
String header2 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 3 +
|
", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
|
", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
|
", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
|
", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";
|
|
List<Double> uList = new ArrayList<Double>();
|
List<Double> vList = new ArrayList<Double>();
|
int x = 0;
|
int y = 0;
|
List<Map> mapList = new ArrayList<Map>();
|
|
for (int j = 0; j < deviceAndWinds.size(); j++) {
|
Map<String, Double> map = new HashMap<String, Double>();
|
Double windDir = deviceAndWinds.get(j).getWindDir();
|
|
Double windSpeed = deviceAndWinds.get(j).getWindSpeed();
|
if (windDir == null) {
|
windDir = 0.0;
|
windSpeed = 0.0;
|
}
|
Double tvoc = deviceAndWinds.get(j).getTVoc();
|
|
List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(deviceAndWinds.get(j).getLatitude(), deviceAndWinds.get(j).getLongitude());
|
Double transLo = (Double) tranlist.get(0);
|
Double transLa = (Double) tranlist.get(1);
|
if (tvoc == null) {
|
tvoc = 0.0;
|
}
|
Double dir = (360.0 - (windDir+180.0) * Math.PI / 180.0);
|
|
U = windSpeed * Math.cos(dir);
|
V = windSpeed * Math.sin(dir);
|
map.put("lo", transLo);
|
map.put("la", transLa);
|
map.put("U", U);
|
map.put("V", V);
|
mapList.add(map);
|
}
|
for (int i = 0; i < mapList.size(); i++) {
|
Double lo = (Double) mapList.get(i).get("lo");
|
Double la = (Double) mapList.get(i).get("la");
|
x = (int) Math.floor((lo - lo1) / dx);
|
y = Math.abs((int) Math.floor((la - la1) / dy));
|
//y=Math.floor(Math.abs(la-la1)/dy);
|
U = (Double) mapList.get(i).get("U");
|
V = (Double) mapList.get(i).get("V");
|
if (i == 0) {
|
for (int j = 0; j < nx * ny; j++) {
|
uList.add(0.0);
|
vList.add(0.0);
|
}
|
}
|
for (int j = 0; j < nx * ny; j++) {
|
if (i == 0) {
|
if ((y >= 2 && j == (y) * nx + x)) {
|
int k;
|
for (k = j - 2 * nx; k <= j + 2 * nx; k = k + nx) {
|
uList.set(k, U);
|
uList.set(k - 1, U);
|
uList.set(k - 2, U);
|
uList.set(k + 1, U);
|
uList.set(k + 2, U);
|
vList.set(k, V);
|
vList.set(k - 1, V);
|
vList.set(k - 2, V);
|
vList.set(k + 1, V);
|
vList.set(k + 2, V);
|
}
|
}
|
} else {
|
if (y >= 1 && j == y * nx + x) {
|
int k;
|
for (k = j - 2 * nx; k <= j + 2 * nx; ) {
|
uList.set(k - 1, U);
|
uList.set(k - 2, U);
|
uList.set(k + 1, U);
|
uList.set(k + 2, U);
|
vList.set(k - 1, V);
|
vList.set(k - 2, V);
|
vList.set(k + 1, V);
|
vList.set(k + 2, V);
|
k = k + nx;
|
}
|
uList.set(j, U);
|
vList.set(j, V);
|
}
|
}
|
}
|
}
|
String uData = "\"" + "data" + "\"" + ": " + uList;
|
String vData = "\"" + "data" + "\"" + ": " + vList;
|
String s1 = "[" + "{" + header1 + ", " + uData + "}" + ", " + "{" + header2 + ", " + vData + "}" + "]";
|
JSONArray jsonArray = JSONArray.parseArray(s1);
|
MonitorPoint monitorPoint = monitorPointMapper.byIdGetMonitorPoint(Integer.parseInt(id));
|
Double monitorLo = monitorPoint.getLongitude();
|
Double monitorLa = monitorPoint.getLatitude();
|
List transList = LatLngTransformation.Convert_BD09_To_GCJ02(monitorLa, monitorLo);
|
Double transLo = (Double) transList.get(0);
|
Double transLa = (Double) transList.get(1);
|
list.add(jsonArray);
|
list.add(transLo);
|
list.add(transLa);
|
list.add(laLaMap);
|
return list;
|
}
|
|
@Override
|
public List byMonitorIdGetDeviceAndWindSpecial(String id, String tab) {
|
MonitorPoint monitorPoint = monitorPointMapper.byIdGetMonitorPoint(Integer.parseInt(id));
|
Integer areaCode = monitorPoint.getAreaCode();
|
String townCode = monitorPoint.getTownCode() + "";
|
int monitorPointId = monitorPoint.getId();
|
Map<String, Object> parm = new HashMap<>();
|
List<DeviceAndWind> deviceAndWinds = new ArrayList<>();
|
Double loma = 0.0;
|
Double lomi = 0.0;
|
Double lama = 0.0;
|
Double lami = 0.0;
|
|
int length = 1;
|
int perdlen = 1;
|
if (areaCode == 320581) {
|
parm.put("areaCode", areaCode);
|
List<Device> deviceList = deviceMapper.getDeviceByCode(parm);
|
for (Device d : deviceList) {
|
String mac = d.getMac();
|
DeviceAndWind deviceAndWind = deviceMapper.byMacGetDeviceAndWind(mac, tab);
|
if (deviceAndWind != null) {
|
deviceAndWinds.add(deviceAndWind);
|
}
|
}
|
length = 8000;
|
perdlen = 2200;
|
} else if ((areaCode == 320583) && (townCode.equals("320583108000"))) {
|
parm.put("townCode", townCode);
|
List<Device> deviceList = deviceMapper.getDeviceByCode(parm);
|
for (Device d : deviceList) {
|
String mac = d.getMac();
|
DeviceAndWind deviceAndWind = deviceMapper.byMacGetDeviceAndWind(mac, tab);
|
if (deviceAndWind != null) {
|
deviceAndWinds.add(deviceAndWind);
|
}
|
}
|
length = 2000;
|
perdlen = 280;
|
} else if (monitorPointId == 35) {
|
DeviceAndWind deviceAndWind = deviceMapper.getDeviceAndWindByMac("898607b0101730392253", tab);
|
DeviceAndWind deviceAndWind1 = deviceMapper.getDeviceAndWindByMac("p5dnd7a0392083", tab);
|
deviceAndWinds.add(deviceAndWind);
|
deviceAndWinds.add(deviceAndWind1);
|
length = 2000;
|
perdlen = 50;
|
|
} else {
|
deviceAndWinds = deviceMapper.byMonitorIdGetDeviceAndWind(Integer.parseInt(id), tab);
|
length = 2000;
|
perdlen = 80;
|
}
|
List loList = new ArrayList();
|
List laList = new ArrayList();
|
Double U = 0.0;
|
Double V = 0.0;
|
List list = new ArrayList();
|
for (DeviceAndWind andWind : deviceAndWinds) {
|
Double lo = andWind.getLongitude();
|
Double la = andWind.getLatitude();
|
List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(la, lo);
|
Double transLo = (Double) tranlist.get(0);
|
Double transLa = (Double) tranlist.get(1);
|
loList.add(transLo);
|
laList.add(transLa);
|
}
|
|
if (loList.size() > 0) {
|
loma = (Double) Collections.max(loList);
|
lomi = (Double) Collections.min(loList);
|
}
|
if (laList.size() > 0) {
|
lama = (Double) Collections.max(laList);
|
lami = (Double) Collections.min(laList);
|
}
|
Map laLaMap = new HashMap();
|
laLaMap.put("maxLo", loma);
|
laLaMap.put("minLo", lomi);
|
laLaMap.put("maxLa", lama);
|
laLaMap.put("minLa", lami);
|
|
Double lo1 = lomi - length * 0.00001141;
|
Double lo2 = loma + length * 0.00001141;
|
Double la2 = lami - length * 0.00000899;
|
Double la1 = lama + length * 0.00000899;
|
|
Double dx = 0.00001141 * perdlen;
|
Double dy = 0.00000899 * perdlen;
|
int nx = (int) Math.floor((lo2 - lo1) / dx);
|
int ny = (int) Math.floor((la1 - la2) / dy);
|
String header1 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 2 +
|
", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
|
", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
|
", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
|
", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";
|
|
String header2 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 3 +
|
", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
|
", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
|
", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
|
", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";
|
|
List<Double> uList = new ArrayList<Double>();
|
List<Double> vList = new ArrayList<Double>();
|
int x = 0;
|
int y = 0;
|
List<Map> mapList = new ArrayList<Map>();
|
|
for (int j = 0; j < deviceAndWinds.size(); j++) {
|
Map<String, Double> map = new HashMap<String, Double>();
|
Double windDir = deviceAndWinds.get(j).getWindDir();
|
Double windSpeed = deviceAndWinds.get(j).getWindSpeed();
|
if (windDir == null) {
|
windDir = 0.0;
|
windSpeed = 0.0;
|
}
|
Double tvoc = deviceAndWinds.get(j).getTVoc();
|
|
List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(deviceAndWinds.get(j).getLatitude(), deviceAndWinds.get(j).getLongitude());
|
Double transLo = (Double) tranlist.get(0);
|
Double transLa = (Double) tranlist.get(1);
|
if (tvoc == null) {
|
tvoc = 0.0;
|
}
|
Double dir = (360.0 - (windDir+180.0) * Math.PI / 180.0);
|
|
U = windSpeed * Math.cos(dir);
|
V = windSpeed * Math.sin(dir);
|
map.put("lo", transLo);
|
map.put("la", transLa);
|
map.put("U", U);
|
map.put("V", V);
|
mapList.add(map);
|
}
|
for (int i = 0; i < mapList.size(); i++) {
|
Double lo = (Double) mapList.get(i).get("lo");
|
Double la = (Double) mapList.get(i).get("la");
|
x = (int) Math.floor((lo - lo1) / dx);
|
y = Math.abs((int) Math.floor((la - la1) / dy));
|
//y=Math.floor(Math.abs(la-la1)/dy);
|
U = (Double) mapList.get(i).get("U");
|
V = (Double) mapList.get(i).get("V");
|
if (i == 0) {
|
for (int j = 0; j < nx * ny; j++) {
|
uList.add(0.0);
|
vList.add(0.0);
|
}
|
}
|
for (int j = 0; j < nx * ny; j++) {
|
if (i == 0) {
|
if ((y >= 2 && j == (y) * nx + x)) {
|
int k;
|
for (k = j - 2 * nx; k <= j + 2 * nx; k = k + nx) {
|
uList.set(k, U);
|
uList.set(k - 1, U);
|
uList.set(k - 2, U);
|
uList.set(k + 1, U);
|
uList.set(k + 2, U);
|
vList.set(k, V);
|
vList.set(k - 1, V);
|
vList.set(k - 2, V);
|
vList.set(k + 1, V);
|
vList.set(k + 2, V);
|
}
|
}
|
} else {
|
if (y >= 1 && j == y * nx + x) {
|
int k;
|
for (k = j - 2 * nx; k <= j + 2 * nx; ) {
|
uList.set(k - 1, U);
|
uList.set(k - 2, U);
|
uList.set(k + 1, U);
|
uList.set(k + 2, U);
|
vList.set(k - 1, V);
|
vList.set(k - 2, V);
|
vList.set(k + 1, V);
|
vList.set(k + 2, V);
|
k = k + nx;
|
}
|
uList.set(j, U);
|
vList.set(j, V);
|
}
|
}
|
}
|
}
|
String uData = "\"" + "data" + "\"" + ": " + uList;
|
String vData = "\"" + "data" + "\"" + ": " + vList;
|
String s1 = "[" + "{" + header1 + ", " + uData + "}" + ", " + "{" + header2 + ", " + vData + "}" + "]";
|
JSONArray jsonArray = JSONArray.parseArray(s1);
|
|
Double monitorLo = monitorPoint.getLongitude();
|
Double monitorLa = monitorPoint.getLatitude();
|
List transList = LatLngTransformation.Convert_BD09_To_GCJ02(monitorLa, monitorLo);
|
Double transLo = (Double) transList.get(0);
|
Double transLa = (Double) transList.get(1);
|
|
list.add(jsonArray);
|
list.add(transLo);
|
list.add(transLa);
|
list.add(laLaMap);
|
return list;
|
}
|
|
@Override
|
public List<Device> getDeviceByCodeAndId(String code, String id) {
|
return deviceMapper.getDeviceByCodeAndId(code, id);
|
}
|
|
@Override
|
public String byMacGetOrgId(String mac) {
|
return deviceMapper.byMacGetOrgId(mac);
|
}
|
|
@Override
|
public List<Device> getDevice(String macOrName) {
|
return deviceMapper.getDevice(macOrName);
|
}
|
|
@Override
|
public List<Device> getDeviceByCode() {
|
return deviceMapper.getDeviceByCityCode();
|
}
|
|
@Override
|
public List<Device> getDevicesByAccountId(String id) {
|
return deviceMapper.getDevicesByAccountId(id);
|
}
|
|
}
|
