From cb888577b99892706860d2732785d22842aae9b0 Mon Sep 17 00:00:00 2001 From: 于紫祥_1901 <email@yuzixiang_1910> Date: Fri, 18 Sep 2020 15:14:34 +0800 Subject: [PATCH] 走行车update --- src/main/java/com/moral/service/impl/DeviceServiceImpl.java | 1126 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 1,056 insertions(+), 70 deletions(-) diff --git a/src/main/java/com/moral/service/impl/DeviceServiceImpl.java b/src/main/java/com/moral/service/impl/DeviceServiceImpl.java index b21b0af..f31a2d0 100644 --- a/src/main/java/com/moral/service/impl/DeviceServiceImpl.java +++ b/src/main/java/com/moral/service/impl/DeviceServiceImpl.java @@ -1,94 +1,1080 @@ package com.moral.service.impl; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; +import java.util.stream.Collectors; import javax.annotation.Resource; +import javax.validation.constraints.NotNull; -import org.springframework.stereotype.Service; -import org.springframework.util.ObjectUtils; - +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������ - @Resource - private DeviceMapper deviceMapper; + //-----------------------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 AccountService accountService; + @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) { - 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 - public List<Map<String, Object>> getSensorsByDevice(String mac) { - return deviceMapper.getSensorsByDevice(mac); - } + @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 - public void saveOrUpdateDevice(Device device) { - ValidateUtil.notNull(device, "������������������"); - ValidateUtil.notEmpty(device.getMac(), "������������������"); - Example example = new Example(Device.class); - example.or().andEqualTo("mac",device.getMac()); - List<Device> devices = deviceMapper.selectByExample(example); - Date operateDate = new Date(); - device.setInstallTime(operateDate); - if (ObjectUtils.isEmpty(devices)) { - device.setCreateTime(operateDate); - device.setState("4"); - deviceMapper.insertSelective(device); - }else if (devices.size() > 1) { - throw new BusinessException("���������������������������������������"); - }else { - device.setId(devices.get(0).getId()); - deviceMapper.updateByPrimaryKeySelective(device); - } - } + @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) { - Example example = new Example(Device.class); - example.or().andEqualTo("operateUserId",uid); - PageHelper.startPage(pageIndex, pageSize); - List<Device> devices = deviceMapper.selectByExample(example); - return devices; - } + @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(Integer.parseInt(id),time,tab); + 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 = (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){ + 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 time, 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,time,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,time,tab); + if (deviceAndWind!=null){ + deviceAndWinds.add(deviceAndWind); + } + } + length=2000; + perdlen=280; + }else if(monitorPointId==35){ + DeviceAndWind deviceAndWind=deviceMapper.getDeviceAndWindByMac("898607b0101730392253",time,tab); + DeviceAndWind deviceAndWind1=deviceMapper.getDeviceAndWindByMac("p5dnd7a0392083",time,tab); + deviceAndWinds.add(deviceAndWind); + deviceAndWinds.add(deviceAndWind1); + length=2000; + perdlen=50; + + }else { + deviceAndWinds=deviceMapper.byMonitorIdGetDeviceAndWind(Integer.parseInt(id),time,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 = (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){ + 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; + } } -- Gitblit v1.8.0