czt
2025-06-10 694f541f9f4bc51818395be84e5ddf322c8048d8
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
package com.ld.igds.m.service;
 
 
import com.bstek.bdf2.core.model.DefaultUser;
import com.bstek.bdf2.core.orm.hibernate.HibernateDao;
import com.ld.igds.common.CoreCommonService;
import com.ld.igds.dto.DepotData;
import com.ld.igds.m.mapper.ManagerMapper;
import com.ld.igds.models.*;
import com.ld.igds.sec.dto.SecCameraDto;
import com.ld.igds.sec.service.CoreSecCameraService;
import com.ld.igds.sys.service.DicTriggerService;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.weather.CoreWeatherService;
 
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * @author chen
 */
@Component
public class HEmergencyCenterService extends HibernateDao {
 
    @Autowired
    private ManagerMapper managerMapper;
    @Autowired
    private CoreCommonService coreCommonService;
    @Autowired
    private DicTriggerService coreDicService;
    @Autowired
    private CoreSecCameraService coreSecCameraService;
    @Autowired
    private CoreWeatherService weatherService;
 
    /**
     * 设置仓库列表显示第一个仓库
     * @return
     */
    public Map<String, Object> getQueryDepot() {
        Map<String, Object> result = new HashMap<>();
        List<Depot> list = coreCommonService.getCacheDepotList(ContextUtil.getCompanyId());
        result.put("depotId", list.get(0).getId());
        return result;
    }
 
    /**
     * 根据仓库id获取仓库信息和保管员电话
     * @param depotId
     * @return
     */
    public DepotData getDepotData(String depotId){
        String companyId = ContextUtil.getCompanyId();
 
        //若仓库id为空,则显示第一个仓库信息
        if(StringUtils.isEmpty(depotId)){
            List<Depot> list = coreCommonService.getCacheDepotList(companyId);
            depotId = list.get(0).getId();
        }
        DepotData depotData = new DepotData();
        //缓存获取仓库信息
        List<Depot> depotList = coreCommonService.getCacheDepotList(companyId);
        //遍历集合
        for (Depot depot : depotList) {
            if(depotId.equals(depot.getId())){
                BeanUtils.copyProperties(depot,depotData);
            }
        }
        //查询保管员电话信息
        if(StringUtils.isNotEmpty(depotData.getStoreKeeperName())){
            //根据保管员名称获取保管员信息
            DefaultUser user = managerMapper.getUserByName(depotData.getStoreKeeperName(),companyId);
            if(user != null){
                if(StringUtils.isNotEmpty(user.getMobile())) {
                    //设置保管员电话信息
                    depotData.setStoreKeeperPhone(user.getMobile());
                }
            }
        }
        return depotData;
    }
 
    /**
     * 获取资产设备信息
     * @param companyId
     * @return
     */
    public Map<String, Object> getAsset(String companyId){
        if(StringUtils.isEmpty(companyId)){
            companyId = ContextUtil.getCompanyId();
        }
        List<OAAsset> assetList = managerMapper.getOAAsset(companyId);
        Map<String, Object> map = new HashMap<>();
        Integer temp = 0;
        for (OAAsset oaAsset : assetList) {
            temp = (Integer) map.get(oaAsset.getCategory());
 
            if(temp == null){
                map.put(oaAsset.getCategory(), 1);
            }else {
                map.put(oaAsset.getCategory(), temp + 1);
            }
        }
        return map;
    }
 
    /**
     * 获取消防信息
     * @param companyId
     * @return
     */
    public Map<String, Object> getFire(String companyId){
        if(StringUtils.isEmpty(companyId)){
            companyId = ContextUtil.getCompanyId();
        }
        List<SecFire> fireList = managerMapper.getSecFire(companyId);
        Map<String, Object> map = new HashMap<>();
        Integer temp1 = 0;
        Integer temp2 = 0;
        if(fireList.size() > 0){
            temp1 = (Integer) fireList.size();
            for (SecFire fire : fireList) {
                temp2 += fire.getNumExtinguisher();
            }
        }
        map.put("消防柜数量", temp1);
        map.put("灭火器数量", temp2);
        return map;
    }
 
    /**
     * 获取粮食数量信息
     * @param companyId
     * @return
     */
    public Map<String, Object> getFoodData(String companyId){
        if (StringUtils.isEmpty(companyId)){
            companyId = ContextUtil.getCompanyId();
        }
        //获取粮食品种字典集合信息
        List<DicTrigger> listFoodVariety = coreDicService.getCacheDicByParent(companyId,
                "FOOD_VARIETY_");
 
        //获取粮食性质字典集合信息
        List<DicTrigger> listFoodType = coreDicService.getCacheDicByParent(
                companyId, "FOOD_TYPE_");
 
        //从缓存获取仓库集合信息
        List<Depot> depotList = coreCommonService.getCacheDepotList(companyId);
 
        Map<String, Object> map = new HashMap<>();
 
        //品种数量临时变量
        Double temp1 ;
        //遍历粮食品种字典集合
        for (DicTrigger trigger : listFoodVariety) {
            temp1 = 0.0;
            String code1 = trigger.getCode();
            //遍历仓库集合
            for (Depot depot : depotList) {
                //设置品种对应数量累加
                if(code1.equals(depot.getFoodVariety())){
                    temp1 += depot.getStorageReal();
                }
            }
            map.put(trigger.getName(), temp1);
        }
 
        //性质数量临时变量
        Double temp2 ;
        //遍历粮食性质字典集合
        for (DicTrigger dicTrigger : listFoodType) {
            temp2 = 0.0;
            String code2 = dicTrigger.getCode();
            //遍历仓库集合
            for (Depot depot : depotList) {
                //设置性质对应数量累加
                if(code2.equals(depot.getFoodType())){
                    temp2 += depot.getStorageReal();
                }
            }
            map.put(dicTrigger.getName(), temp2);
        }
        return map;
    }
 
    /**
     *缓存获取监控设备列表
     * @return
     */
    public List<SecCameraDto> getCameraList() {
        return coreSecCameraService.getAllCacheCamera(ContextUtil.getCompanyId());
    }
 
    /**
     * 获取摄像头信息
     * @param id
     * @return
     */
    public SecCameraDto getCameraData(String id){
        //缓存中获取监控设备信息
        List<SecCameraDto> list = coreSecCameraService.getAllCacheCamera(ContextUtil.getCompanyId());
 
        //若id为空,则直接返回集合中第一个设备信息
        if(StringUtils.isEmpty(id)){
            return list.get(0);
        }
        //不为空则遍历集合
        for (SecCameraDto cameraDto : list) {
            if(id.equals(cameraDto.getId())){
                return cameraDto;
            }
        }
        return null;
    }
 
    public WeatherInfo getWeatherData(String companyId) {
        return weatherService.getCacheWeather(companyId);
    }
}