波动补偿

于紫祥_1901

2020-12-24 f28149d8183a62f87fa9c8df9ae589070d83f612

 src/main/java/com/moral/service/impl/DeviceServiceImpl.java

@@ -1,1101 +1,1138 @@
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);

            System.out.println(params);

            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);

        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 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 = (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;

    }



    @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();

    }



}

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);
    }

}