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.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;
|
|
@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");
|
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.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 time,String tab) {
|
|
List<DeviceAndWind> deviceAndWinds=deviceMapper.byMonitorIdGetDeviceAndWind(id,time,tab);
|
List loList=new ArrayList();
|
List laList=new ArrayList();
|
Double U=0.0;
|
Double V=0.0;
|
for (DeviceAndWind andWind : deviceAndWinds) {
|
List list2=new ArrayList();
|
Double lo=andWind.getLongitude();
|
Double la=andWind.getLatitude();
|
List list= LatLngTransformation.Convert_BD09_To_GCJ02(la,lo);
|
Double transLo=(Double) list.get(0);
|
Double transLa=(Double) list.get(1);
|
loList.add(transLo);
|
log.info(loList.size());
|
log.info(loList);
|
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) loList.get(0);
|
lomi= (Double) loList.get(0);
|
}
|
if (laList.size()>0){
|
lama= (Double) laList.get(0);
|
lami= (Double) laList.get(0);
|
}
|
for (int i = 1; i <loList.size() ; i++) {
|
if (loma<=(Double) loList.get(i)){
|
loma=(Double) loList.get(i);
|
}
|
if (lomi>=(Double) loList.get(i)){
|
lomi=(Double) loList.get(i);
|
}
|
}
|
|
for (int i = 1; i <laList.size() ; i++) {
|
if (lama<=(Double) laList.get(i)){
|
lama=(Double) laList.get(i);
|
}
|
if (lami>=(Double) laList.get(i)){
|
lami=(Double) laList.get(i);
|
}
|
}
|
|
Map laLaMap=new HashMap();
|
laLaMap.put("maxLo",loma);
|
laLaMap.put("minLo",lomi);
|
laLaMap.put("maxLa",lama);
|
laLaMap.put("lami",lami);
|
System.out.println(laLaMap);
|
|
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 list= LatLngTransformation.Convert_BD09_To_GCJ02(deviceAndWinds.get(j).getLatitude(),deviceAndWinds.get(j).getLongitude());
|
Double transLo=(Double) list.get(0);
|
Double transLa=(Double) list.get(1);
|
if (tvoc==null){
|
tvoc=0.0;
|
}
|
Double dir = (270.0 - windDir * 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 && uList.get(j)==0.0 && vList.get(j)==0.0){
|
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 list=new ArrayList();
|
list.add(jsonArray);
|
list.add(transLo);
|
list.add(transLa);
|
list.add(laLaMap);
|
return list;
|
}
|
|
@Override
|
public DeviceAndWind getDeviceAndWindByMac(String mac,String time,String table) {
|
return deviceMapper.getDeviceAndWindByMac(mac,time,table);
|
}
|
}
|
