五分钟表相关代码，平均风向、平局风速工具类

lizijie

2020-12-03 a66d53c3cbfb0024804045f4d795be06089d4f9d

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package com.moral.service.impl;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.springframework.stereotype.Service;
 
import com.moral.common.bean.PageBean;
import com.moral.common.util.MyBatisBaseMapUtil;
import com.moral.common.util.RedisUtils;
import com.moral.entity.DeviceVersion;
import com.moral.entity.DeviceVersionSensor;
import com.moral.mapper.DeviceVersionMapper;
import com.moral.mapper.DeviceVersionSensorMapper;
import com.moral.service.DeviceVersionService;
 
import tk.mybatis.mapper.entity.Example;
 
@Service
public class DeviceVersionServiceImpl implements DeviceVersionService {
      @Resource
      private DeviceVersionMapper deviceVersionMapper;
      @Resource
      private DeviceVersionSensorMapper deviceVersionSensorMapper;
      private static Class ENTITY_CLASS = DeviceVersion.class;
      @Override
      public PageBean queryByPageBean(PageBean pageBean){
           return MyBatisBaseMapUtil.queryPage(deviceVersionMapper,pageBean,ENTITY_CLASS);
      }
      @Override
      public void addOrModify(DeviceVersion deviceVersion){
            try{
                  if(deviceVersion.getId()==null){
                        deviceVersion.setUpdateTime(new Date());
                        deviceVersionMapper.insertSelective(deviceVersion);
                  }else{
                        deviceVersion.setUpdateTime(new Date());
                        deviceVersionMapper.updateByPrimaryKeySelective(deviceVersion);
                  }
            }
            catch (Exception ex){
                  throw  ex;
            }
      }
 
      @Override
      public void deleteByIds(Integer... ids) {
            if(ids!=null&&ids.length>0){
                  if(ids.length==1){
                        DeviceVersion deviceVersion = new DeviceVersion();
                        deviceVersion.setId(ids[0]);
                        deviceVersion.setIsDelete(true);
                        deviceVersion.setUpdateTime(new Date());
                        deviceVersionMapper.updateByPrimaryKeySelective(deviceVersion);
                  }else{
                        DeviceVersion deviceVersion = new DeviceVersion();
                        deviceVersion.setIsDelete(true);
                        deviceVersion.setUpdateTime(new Date());
                        Example example = new Example(ENTITY_CLASS);
                        example.or().andIn("id", Arrays.asList(ids));
                        deviceVersionMapper.updateByExampleSelective(deviceVersion,example);
                  }
 
            }
      }
      
      @Resource
      private RedisUtils redisUtils;
      @Override
      public void versionSensorConfig(Integer deviceVersionId, Integer[] sensorIds){
            Example example = new Example(DeviceVersionSensor.class);
            example.or().andEqualTo("deviceVersionId",deviceVersionId);
            deviceVersionSensorMapper.deleteByExample(example);
            redisUtils.remove("deviceVersion_" + deviceVersionId);
            if(sensorIds!=null && sensorIds.length >0){
                  List<DeviceVersionSensor> deviceVersionSensorList = new ArrayList<DeviceVersionSensor>();
                  for(int sensorId:sensorIds){
                        DeviceVersionSensor deviceVersionSensor = new DeviceVersionSensor();
                        deviceVersionSensor.setDeviceVersionId(deviceVersionId);
                        deviceVersionSensor.setSensorId(sensorId);
                        deviceVersionSensorList.add(deviceVersionSensor);
                  }
                  deviceVersionSensorMapper.insertList(deviceVersionSensorList);
            }
      }
      public List<DeviceVersion> getVersionsByOrgId(int organizationId){
            return null;
      }
 
      @Override
      public Integer queryMaxVersionNo() {
            Example example = new Example(DeviceVersion.class);
            example.orderBy("version").desc();
            List<DeviceVersion> deviceVersionList = deviceVersionMapper.selectByExample(example);
            if(deviceVersionList.size()>0){
                  return deviceVersionList.get(0).getVersion();
            }
            return null;
      }
      @Override
      public DeviceVersion queryByVersionNo(int versionNo) {
            DeviceVersion query = new DeviceVersion();
            query.setVersion(versionNo);
            return deviceVersionMapper.selectOne(query);
      }
      @Override
      public List<Integer> getSensorIds(int deviceVersionId){
            DeviceVersionSensor deviceVersionSensor = new DeviceVersionSensor();
            deviceVersionSensor.setDeviceVersionId(deviceVersionId);
            List<DeviceVersionSensor> deviceVersionSensorList = deviceVersionSensorMapper.select(deviceVersionSensor);
            List<Integer> sensorIds = new ArrayList<>();
            for(DeviceVersionSensor dvSensor:deviceVersionSensorList ){
                  sensorIds.add(dvSensor.getSensorId());
            }
            return sensorIds;
      }
      @Override
      public  List<DeviceVersion> queryByOrgId(Integer organizationId){
            return  this.deviceVersionMapper.selectListByOrgId(organizationId);
      }
      @Override
      public  List<DeviceVersion> queryByMpointId(Integer mpointId){
            return  this.deviceVersionMapper.selectListByMpointId(mpointId);
      }
 
      @Override
      public DeviceVersion queryVersionById(Integer versionId) {
            return deviceVersionMapper.selectByPrimaryKey(versionId);
      }
 
}