设备升级，用xml解析，江陵

  1 package com.hikvision.cms.vss.biz.res.respoint.camera.service.impl;
  2 
  3 import com.hikvision.cms.common.entity.UserLoginPojo;
  4 import com.hikvision.cms.common.util.XmlUtil;
  5 import com.hikvision.cms.common.util.log.LogUtils;
  6 import com.hikvision.cms.util.frame.tool.BeanUtil;
  7 import com.hikvision.cms.util.frame.tool.ValidateUtil;
  8 import com.hikvision.cms.vss.biz.res.device.encoder.dao.condition.EncoderCondition;
  9 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.enums.EncoderRequestEnum;
 10 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.request.ftp.FtpBasicRequestForMany;
 11 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.request.ftp.FtpPackRequestForMany;
 12 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.request.ftp.FtpParamsForMany;
 13 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.response.ftp.FtpBasicInfoResponse;
 14 import com.hikvision.cms.vss.biz.res.device.encoder.dto.xml.config.response.ftp.FtpBasicResponsePack;
 15 import com.hikvision.cms.vss.biz.res.device.encoder.entity.Encoder;
 16 import com.hikvision.cms.vss.biz.res.device.encoder.service.IEncoderBasicService;
 17 import com.hikvision.cms.vss.biz.res.device.encoder.util.EncoderCfgUtil;
 18 import com.hikvision.cms.vss.biz.res.respoint.camera.dao.CameraDao;
 19 import com.hikvision.cms.vss.biz.res.respoint.camera.dao.CameraUpgradeDao;
 20 import com.hikvision.cms.vss.biz.res.respoint.camera.dto.CameraUpgradeDto;
 21 import com.hikvision.cms.vss.biz.res.respoint.camera.dto.cfg.CameraUpgradeResultDetailXml;
 22 import com.hikvision.cms.vss.biz.res.respoint.camera.dto.cfg.CameraUpgradeResultXml;
 23 import com.hikvision.cms.vss.biz.res.respoint.camera.entity.Camera;
 24 import com.hikvision.cms.vss.biz.res.respoint.camera.entity.CameraUpgrade;
 25 import com.hikvision.cms.vss.biz.res.respoint.camera.entity.CameraUpgradePlan;
 26 import com.hikvision.cms.vss.biz.res.respoint.camera.service.ICameraUpgrade;
 27 import com.hikvision.cms.vss.biz.res.server.gateway.vag.dao.condition.VagServerCondition;
 28 import com.hikvision.cms.vss.biz.res.server.gateway.vag.entity.VagServer;
 29 import com.hikvision.cms.vss.biz.res.server.gateway.vag.service.impl.VagServerBasicService;
 30 import com.hikvision.cms.vss.common.constparam.ConstparamEventType;
 31 import com.hikvision.cms.vss.common.constparam.ConstparamResponseCode;
 32 import com.hikvision.cms.vss.common.constparam.ConstparamTip;
 33 import com.hikvision.cms.vss.mq.accept.event.dto.Event;
 34 import com.hikvision.vag.api.dto.VagResult;
 35 import org.apache.commons.lang3.StringUtils;
 36 import org.springframework.stereotype.Service;
 37 
 38 import javax.annotation.Resource;
 39 import java.sql.Timestamp;
 40 import java.util.*;
 41 
 42 /**
 43  * 监控点升级服务
 44  */
 45 @Service("cameraUpgradeService")
 46 public class CameraUpgradeService implements ICameraUpgrade {
 47 
 48     final static Integer UPDATE_COMPLETE = 3;
 49     final static Integer UPDATE_FAIL = 2;
 50     final static Integer UPDATE_DOING = 1;
 51     final static Integer UPDATE_SEND_FAIL = 0;
 52     final static Integer ENCODER_TYPE = 4;
 53     final static Integer CAMERA_TYPE = 3;
 54 
 55     /**
 56      * 监控点批量升级dao
 57      */
 58     @Resource
 59     private CameraUpgradeDao cameraUpgradeDao;
 60 
 61     @Resource
 62     private CameraDao cameraDao;
 63 
 64     @Resource
 65     private VagServerBasicService vagServerBasicService;
 66 
 67     @Resource
 68     private CameraUpgradePlanService cameraUpgradePlanService;
 69 
 70     @Resource
 71     private IEncoderBasicService encoderBasicService;
 72 
 73     /**
 74      * 批量保存监控点
 75      *
 76      * @param
 77      * @return
 78      */
 79     @Override
 80     public void addCameras(List<CameraUpgrade> cameraUpgrades) {
 81         if (ValidateUtil.isEmpty(cameraUpgrades)) {
 82             return;
 83         }
 84         cameraUpgradeDao.saveList(cameraUpgrades);
 85     }
 86 
 87     /**
 88      * 批量更新监控点
 89      *
 90      * @param
 91      */
 92     @Override
 93     public void upadateCameras(List<CameraUpgrade> cameraUpgrades) {
 94         if (ValidateUtil.isEmpty(cameraUpgrades)) {
 95             return;
 96         }
 97         cameraUpgradeDao.updateList(cameraUpgrades);
 98     }
 99 
100 
101     /**
102      * 根据planId查询CameraUpgrade
103      *
104      * @param
105      * @return
106      */
107     @Override
108     public List<CameraUpgrade> findPlanId(Integer planId) {
109         List<CameraUpgrade> cameraUpgradeList = null;
110         if (planId != null) {
111             cameraUpgradeList = cameraUpgradeDao.fetchByPlanId(planId);
112              if(ValidateUtil.isNotEmpty(cameraUpgradeList)){
113                  for (CameraUpgrade cameraUpgrade : cameraUpgradeList) {
114                      if(cameraUpgrade.getStatus() == 1){
115                          long createTime = cameraUpgrade.getCreateTime().getTime();
116                          long nowTime = System.currentTimeMillis();
117                          long time = Math.abs(nowTime-createTime);
118                          long hh = time / 1000 / 60 / 60;
119                          LogUtils.logInfo("间隔时间是：",hh);
120                          if (hh >= 6){
121                              //间隔时间超过6个小时
122                              //更改状态值为升级失败 3  添加升级失败描述
123                              cameraUpgradeDao.updateCameraStatusByCameraSyscodeAndPlanIdAndStatus(cameraUpgrade.getId(),3);
124                          }
125                      }
126                  }
127              }
128         }
129         return cameraUpgradeList;
130     }
131 
132     /**
133      * 根据id来查询cameraUpgrade
134      *
135      * @param id
136      * @return
137      */
138     @Override
139     public CameraUpgrade findById(Integer id) {
140         CameraUpgrade cameraUpgrade = cameraUpgradeDao.findById(id);
141         return cameraUpgrade;
142     }
143 
144     @Override
145     public Integer theKeyToUpgradeEquip(CameraUpgradeDto cameraUpgradeDto,UserLoginPojo userLoginPojo) {
146         String nodeType = cameraUpgradeDto.getNodeType();
147 
148         if (ValidateUtil.isEmpty(nodeType)) {
149             throw new RuntimeException("设备类型异常！");
150         }
151         Integer nodeTypeInteger = Integer.valueOf(nodeType);
152         if (ENCODER_TYPE.equals(nodeTypeInteger)) {
153             //是NVR设备 直接组装VAG和NVR的信息
154 
155             CameraUpgradePlan cameraUpgradePlan = new CameraUpgradePlan();
156             String isUpgradeCamera = "";
157             //设置计划名称
158             cameraUpgradePlan.setPlanName(cameraUpgradeDto.getUpgradePlanName());
159             //设置升级文件名称
160             cameraUpgradePlan.setUpgradeFileName(cameraUpgradeDto.getFileName());
161             //设置计划时间
162             Timestamp planTime = new Timestamp(System.currentTimeMillis());
163             cameraUpgradePlan.setPlanTime(planTime);
164             cameraUpgradePlan.setUser(userLoginPojo.getUser_name());
165             //设置fipip
166             cameraUpgradePlan.setFtpIp(cameraUpgradeDto.getFtpIp());
167             //设置ftpport
168             cameraUpgradePlan.setFtpPort(cameraUpgradeDto.getFtpPort());
169             //保存该计划
170             String[] encoderIds = cameraUpgradeDto.getCameraSyscodes();
171             List<Integer> encoderIdlist = new ArrayList<>();
172             for (String encoderId : encoderIds) {
173                 encoderIdlist.add(Integer.parseInt(encoderId));
174             }
175             //获取EncoderList
176             EncoderCondition encoderCondition = new EncoderCondition();
177             encoderCondition.setEncoderIdList(encoderIdlist);
178             List<Encoder> encoderList = encoderBasicService.fetchList(encoderCondition);
179             //判断是否在升级中 在升级中 则不给升级  并返回
180             Iterator<Encoder> iter = encoderList.iterator();
181             while (iter.hasNext()) {
182                 Encoder encoder = iter.next();
183                 String encoderSyscode = encoder.getSysCode();
184                 boolean isUpgrading = cameraUpgradeDao.isUpgradeingEncoder(encoderSyscode);
185                 if (isUpgrading) {
186                     isUpgradeCamera += encoder.getEncoderName() + "，";
187                     iter.remove();
188                 }
189             }
190             if (ValidateUtil.isEmpty(encoderList)) {
191                 if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
192                     throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
193                 } else {
194                     throw new RuntimeException("无需要升级的设备！");
195                 }
196             }
197             Integer planId = cameraUpgradePlanService.addCameraUpgradePlan(cameraUpgradePlan);
198             //通过cameraSyscodes查询出所有的Camera;
199 
200             //设置计划ID
201             List<CameraUpgrade> cameraUpgrades = new ArrayList<>();
202             for (Encoder encoder : encoderList) {
203                 CameraUpgrade cameraUpgrade = new CameraUpgrade();
204                 cameraUpgrade.setPlanId(planId);
205                 cameraUpgrade.setEncoderName(encoder.getEncoderName());
206                 cameraUpgrade.setEncoderSyscode(encoder.getSysCode());
207                 Timestamp timestamp = new Timestamp(System.currentTimeMillis());
208                 cameraUpgrade.setUpgradeFile(cameraUpgradeDto.getFileName());
209                 cameraUpgrade.setCreateTime(timestamp);
210                 cameraUpgrade.setUpdateTime(timestamp);
211                 cameraUpgrades.add(cameraUpgrade);
212             }
213             //保存cameraUpgrade
214             this.addCameras(cameraUpgrades);
215 
216             //处理cameraList encoderId 和 通道号对应起来
217             //此处的通道号的字符串最后会多一个“，”出来。考虑设备多的情况下再进行一次循环太费性能，故在封装报文的时候进行
218             Map<Integer,Map<String,String>> vagEncoderChannel = dealWithEncoderChannalForEncoder(encoderList);
219             //组装XML，下发VAG
220             String upgradeMessage = toUpgradeEquip(vagEncoderChannel,cameraUpgradeDto,planId);
221             //
222             if (upgradeMessage != null && !"".equals(upgradeMessage)) {
223                 throw new RuntimeException(upgradeMessage);
224             } else if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
225                 throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
226             } else {
227                 return planId; //id为计划ID
228             }
229 
230         } else if (CAMERA_TYPE.equals(nodeTypeInteger)) {
231             //是监控点设备
232             CameraUpgradePlan cameraUpgradePlan = new CameraUpgradePlan();
233             String isUpgradeCamera = "";
234             //设置计划名称
235             cameraUpgradePlan.setPlanName(cameraUpgradeDto.getUpgradePlanName());
236             //设置升级文件名称
237             cameraUpgradePlan.setUpgradeFileName(cameraUpgradeDto.getFileName());
238             //设置计划时间
239             Timestamp planTime = new Timestamp(System.currentTimeMillis());
240             cameraUpgradePlan.setPlanTime(planTime);
241             cameraUpgradePlan.setUser(userLoginPojo.getUser_name());
242             //设置fipip
243             cameraUpgradePlan.setFtpIp(cameraUpgradeDto.getFtpIp());
244             //设置ftpport
245             cameraUpgradePlan.setFtpPort(cameraUpgradeDto.getFtpPort());
246             //保存该计划
247             String[] cameraSyscodes = cameraUpgradeDto.getCameraSyscodes();
248             List<Camera> cameraList = cameraDao.getCameraBySyscodes(cameraSyscodes);
249             //判断是否在升级中 在升级中 则不给升级  并返回
250             Iterator<Camera> iter = cameraList.iterator();
251             while (iter.hasNext()) {
252                 Camera camera = iter.next();
253                 String cameraSyscode = camera.getSysCode();
254                 boolean isUpgrading = cameraUpgradeDao.isUpgradeing(cameraSyscode);
255                 boolean isUpgradingEncoder = cameraUpgradeDao.isUpgradeingEncoder(camera.getEncoder().getSysCode());
256                 if (isUpgrading || isUpgradingEncoder) {
257                     isUpgradeCamera += camera.getCameraName() + "，";
258                     iter.remove();
259                 }
260             }
261             if (ValidateUtil.isEmpty(cameraList)) {
262                 if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
263                     throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
264                 } else {
265                     throw new RuntimeException("无需要升级的设备！");
266                 }
267             }
268             Integer planId = cameraUpgradePlanService.addCameraUpgradePlan(cameraUpgradePlan);
269             //通过cameraSyscodes查询出所有的Camera;
270 
271             //设置计划ID
272             List<CameraUpgrade> cameraUpgrades = new ArrayList<>();
273             for (Camera camera : cameraList) {
274                 CameraUpgrade cameraUpgrade = new CameraUpgrade();
275                 cameraUpgrade.setPlanId(planId);
276                 cameraUpgrade.setCameraName(camera.getCameraName());
277                 cameraUpgrade.setCameraSyscode(camera.getSysCode());
278                 Encoder encoder = camera.getEncoder();
279                 cameraUpgrade.setEncoderName(encoder.getEncoderName());
280                 cameraUpgrade.setEncoderSyscode(encoder.getSysCode());
281                 cameraUpgrade.setCameraChannelNum(camera.getCameraChannelNum());
282 
283                 Timestamp timestamp = new Timestamp(System.currentTimeMillis());
284                 cameraUpgrade.setUpgradeFile(cameraUpgradeDto.getFileName());
285                 cameraUpgrade.setCreateTime(timestamp);
286                 cameraUpgrade.setUpdateTime(timestamp);
287                 cameraUpgrades.add(cameraUpgrade);
288             }
289             //保存cameraUpgrade
290             this.addCameras(cameraUpgrades);
291 
292             //处理cameraList encoderId 和 通道号对应起来
293             //此处的通道号的字符串最后会多一个“，”出来。考虑设备多的情况下再进行一次循环太费性能，故在封装报文的时候进行
294             Map<Integer,String>> vagEncoderChannel = dealWithEncoderChannal(cameraList);
295             //组装XML，下发VAG
296             String upgradeMessage = toUpgradeEquip(vagEncoderChannel,planId);
297             //
298             if (upgradeMessage != null && !"".equals(upgradeMessage)) {
299                 throw new RuntimeException(upgradeMessage);
300             } else if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
301                 throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
302             } else {
303                 return planId; //id为计划ID
304             }
305         } else {
306             throw new RuntimeException("未知的设备类型。");
307         }
308 
309     }
310 
311 
312     /**
313      * 将监控点的集合转换成 （vagId:(编码设备sysCode:通道号集合的字符串)）格式
314      *
315      * @param cameraList
316      * @return
317      */
318     private Map<Integer,String>> dealWithEncoderChannal(List<Camera> cameraList) {
319         Map<Integer,String>> vagEncoderMap = new HashMap<>();
320         List<Encoder> encoderList = BeanUtil.fetchPropertyValue(cameraList,"encoder",Encoder.class);
321         //考虑多个VAG情况
322         Set<Encoder> encoderSet = new HashSet<>();
323         encoderSet.addAll(encoderList);
324         //encoderIdSet 去重后的设备ID
325         //
326         //首先 根据VAGID分组
327         for (Encoder encoder : encoderSet) {
328             Integer vagEncoderID = encoder.getVagServerId();
329             Map<String,String> encoderChannelMap = vagEncoderMap.get(vagEncoderID);
330             if (ValidateUtil.isNull(encoderChannelMap)) {
331                 encoderChannelMap = new HashMap<>();
332             }
333             for (Camera camera : cameraList) {
334                 String encoderSyscode = camera.getEncoder().getSysCode();
335                 if (ValidateUtil.isNull(encoderChannelMap)) {
336                     encoderChannelMap = new HashMap<>();
337                 }
338                 String channel = encoderChannelMap.get(encoderSyscode);
339                 if (channel == null) {
340                     channel = "";
341                 }
342                 channel += camera.getCameraChannelNum() + ",";
343                 encoderChannelMap.put(encoderSyscode,channel);
344             }
345             vagEncoderMap.put(vagEncoderID,encoderChannelMap);
346         }
347         return vagEncoderMap;
348     }
349 
350     /**
351      * 将监控点的集合转换成 （vagId:(编码设备sysCode:通道号集合的字符串)）格式
352      *
353      * @param
354      * @return
355      */
356     private Map<Integer,String>> dealWithEncoderChannalForEncoder(List<Encoder> encoderList) {
357         Map<Integer,String>> vagEncoderMap = new HashMap<>();
358         //考虑多个VAG情况
359         Set<Encoder> encoderSet = new HashSet<>();
360         encoderSet.addAll(encoderList);
361         //encoderIdSet 去重后的设备ID
362         //
363         //首先 根据VAGID分组
364         for (Encoder encoder : encoderSet) {
365             Integer vagEncoderID = encoder.getVagServerId();
366             Map<String,String> encoderChannelMap = vagEncoderMap.get(vagEncoderID);
367             if (ValidateUtil.isNull(encoderChannelMap)) {
368                 encoderChannelMap = new HashMap<>();
369             }
370             encoderChannelMap.put(encoder.getSysCode(),"");
371             vagEncoderMap.put(vagEncoderID,encoderChannelMap);
372         }
373         return vagEncoderMap;
374     }
375 
376     /**
377      * 针对不同的VAG 不同的设备下发报文到VAG
378      *
379      * @param vagEncoderChannel VAG,Encoder,通道号的对应map
380      * @param cameraUpgradeDto  升级参数
381      * @return
382      */
383     public String toUpgradeEquip(Map<Integer,String>> vagEncoderChannel,CameraUpgradeDto cameraUpgradeDto,Integer planId) {
384         String errMsg = "";
385         String fileName = cameraUpgradeDto.getFileName();
386         String ftpIp = cameraUpgradeDto.getFtpIp();
387         String ftpPort = cameraUpgradeDto.getFtpPort();
388         String ftpUserName = cameraUpgradeDto.getFtpUserName();
389         String ftpPsd = cameraUpgradeDto.getFtpPsd();
390 
391         FtpBasicRequestForMany ftpBasicRequestForMany = new FtpBasicRequestForMany();
392         FtpPackRequestForMany ftpPackRequestForMany = new FtpPackRequestForMany();
393 
394         /**组装FTP的通用的参数 通道号在循环里面加**/
395         FtpParamsForMany ftpParamsForMany = new FtpParamsForMany();
396         ftpParamsForMany.setFileName(fileName);
397         ftpParamsForMany.setFtpServerIP(ftpIp);
398         ftpParamsForMany.setFtpServerPort(Integer.valueOf(ftpPort.trim()));
399         ftpParamsForMany.setFtpServerUserName(ftpUserName);
400         ftpParamsForMany.setFtpServerUserPwd(ftpPsd);
401         ftpPackRequestForMany.setCommandType(EncoderRequestEnum.REQUEST.code());
402         ftpPackRequestForMany.setCommand(EncoderRequestEnum.UPDATE.code());
403         //一样的参数 实现先做好 之后的循环VAG的参数 在每个VAG的下面再去根据encoder 去组装需要下发的报文 之后循环下发
404         for (Map.Entry<Integer,String>> entry : vagEncoderChannel.entrySet()) {
405             Integer vagId = entry.getKey();
406             //对应不同的VAG下发不同的报文
407             VagServerCondition vagServerCondition = new VagServerCondition();
408             vagServerCondition.setVagServerId(vagId);
409             VagServer vagServer = vagServerBasicService.fetchSingle(vagServerCondition);
410 
411             Map<String,String> encoderChannelMap = entry.getValue();
412             for (Map.Entry<String,String> encoderChannel : encoderChannelMap.entrySet()) {
413                 String encoderIndex = encoderChannel.getKey();
414                 String channel = encoderChannel.getValue();
415                 //写入报文时去除逗号
416                 ftpBasicRequestForMany.setDevIndexCode(encoderIndex);
417                 if (!"".equals(channel)) {
418                     ftpParamsForMany.setChannels(channel.substring(0,channel.length() - 1));
419                 }
420                 ftpPackRequestForMany.setFtpParamsForMany(ftpParamsForMany);
421                 ftpBasicRequestForMany.setFtpPackRequestForMany(ftpPackRequestForMany);
422                 VagResult result = EncoderCfgUtil.fetchVagResult(vagServer.getServerGroup().getIp(),vagServer.getSocketPort(),ftpBasicRequestForMany,EncoderRequestEnum.UPDATE.description());
423                 if (ConstparamResponseCode.ERROR_CODE_ZERO.equals(result.getErrorCode())) {
424                     FtpBasicInfoResponse fetchProcotol = com.hikvision.cms.util.frame.xmlanalyze.XmlUtil.unMarshaller(FtpBasicInfoResponse.class,result.getResponseXml());
425                     FtpBasicResponsePack pack = fetchProcotol.getBasicResponsePack();
426                     if (!ConstparamResponseCode.STATUS_CODE_OK.equals(pack.getStatus())) {
427                         //根据通道号和encoderIndex更新
428                         this.updateUpgrageStatus(encoderIndex,channel,CameraUpgradeService.UPDATE_SEND_FAIL,"下发VAG失败",planId);
429                         if ("".equals(channel)) {
430                             errMsg =  "部分设备下发失败";
431                         } else {
432                             errMsg =  "部分设备下发失败";
433                         }
434                     }
435                 } else {
436                     //根据encoderIndex channel 去更新为下发失败
437                     this.updateUpgrageStatus(encoderIndex,"与VAG通信失败！",planId);
438                     errMsg = ConstparamTip.CON_VAG_FAIL;
439                 }
440             }
441         }
442         return errMsg;
443     }
444 
445     public void updateUpgrageStatus(String encoderIndex,String channels,Integer status,String errorDes,Integer plan_id) {
446         if(StringUtils.isEmpty(channels)){
447             cameraUpgradeDao.updateCameraStatusByEncoderSyscode(encoderIndex,status,errorDes,plan_id);
448         }else{
449             String[] channelArray = channels.split(",");
450             for (String channel : channelArray) {
451                 cameraUpgradeDao.updateCameraStatusByEncoderSyscodeAndChannelId(encoderIndex,Integer.parseInt(channel),plan_id);
452             }
453         }
454     }
455 
456 
457     public void reUpgradeCameraByPlanId(Integer planId,String ftpUser,String ftpPwd) {
458         //通过planID查询出该计划下失败的升级计划
459         List<CameraUpgrade> cameraUpgradeFailList = cameraUpgradeDao.findFailCameraUpgradeByPlanId(planId);
460         //判断监控点是否又重新下发了
461         String isUpgradeCamera = "";
462         int planType = 0;
463         Iterator<CameraUpgrade> iter = cameraUpgradeFailList.iterator();
464         while (iter.hasNext()) {
465             CameraUpgrade cameraUpgrade = iter.next();
466             String cameraSyscode = cameraUpgrade.getCameraSyscode();
467             String encoderSyscode = cameraUpgrade.getEncoderSyscode();
468             if (ValidateUtil.isNotEmpty(cameraSyscode)) {
469                 boolean isUpgrading = cameraUpgradeDao.isUpgradeing(cameraSyscode);
470                 boolean isUpgradingEncoder = cameraUpgradeDao.isUpgradeingEncoder(encoderSyscode);
471                 if (isUpgrading || isUpgradingEncoder) {
472                     isUpgradeCamera += cameraUpgrade.getCameraName() + "，";
473                     iter.remove();
474                 }
475             } else {
476                 planType = 1;
477                 boolean isUpgradingEncoder = cameraUpgradeDao.isUpgradeingEncoder(encoderSyscode);
478                 if (isUpgradingEncoder) {
479                     isUpgradeCamera += cameraUpgrade.getEncoderName() + "，";
480                     iter.remove();
481                 }
482             }
483         }
484         if (ValidateUtil.isEmpty(cameraUpgradeFailList)) {
485             if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
486                 throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
487             } else {
488                 throw new RuntimeException("无需要升级的设备！");
489             }
490         }
491         //得到需要下发的监控点的syscode
492         if (planType == 0) {
493             //监控点
494             List<String> reCameraSyscode = BeanUtil.fetchPropertyValue(cameraUpgradeFailList,"cameraSyscode",String.class);
495 
496             //根据监控点的syscode和planId去更新数据库存储的信息
497             cameraUpgradeDao.updateCameraStatusByCameraSyscodeAndPlanId(reCameraSyscode,planId,this.UPDATE_DOING);
498 
499             //通过planID去查询出对应计划的FTP信息
500             CameraUpgradePlan cameraUpgradePlan = cameraUpgradePlanService.fetchCameraUpgradePlanById(planId);
501             String ftpIp = cameraUpgradePlan.getFtpIp();
502             String ftpPort = cameraUpgradePlan.getFtpPort();
503             String fileName = cameraUpgradePlan.getUpgradeFileName();
504 
505             //转换监控点信息
506             List<Camera> cameraList = cameraDao.getCameraBySyscodes(reCameraSyscode.toArray(new String[reCameraSyscode.size()]));
507             Map<Integer,String>> encoderChannalMap = dealWithEncoderChannal(cameraList);
508 
509             //封装条件
510             CameraUpgradeDto cameraUpgradeDto = new CameraUpgradeDto();
511             cameraUpgradeDto.setFtpIp(ftpIp);
512             cameraUpgradeDto.setFtpPort(ftpPort);
513             cameraUpgradeDto.setFtpUserName(ftpUser);
514             cameraUpgradeDto.setFtpPsd(ftpPwd);
515             cameraUpgradeDto.setFileName(fileName);
516             String upgradeMessage = toUpgradeEquip(encoderChannalMap,planId);
517             if (upgradeMessage != null && !"".equals(upgradeMessage)) {
518                 throw new RuntimeException(upgradeMessage);
519             } else if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
520                 throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
521             }
522         } else {
523             //设备
524             List<String> reEncoderSyscode = BeanUtil.fetchPropertyValue(cameraUpgradeFailList,"encoderSyscode",String.class);
525 
526             //根据监控点的syscode和planId去更新数据库存储的信息
527             cameraUpgradeDao.updateCameraStatusByCameraSyscodeAndPlanIdForEncoder(reEncoderSyscode,this.UPDATE_DOING);
528 
529             //通过planID去查询出对应计划的FTP信息
530             CameraUpgradePlan cameraUpgradePlan = cameraUpgradePlanService.fetchCameraUpgradePlanById(planId);
531             String ftpIp = cameraUpgradePlan.getFtpIp();
532             String ftpPort = cameraUpgradePlan.getFtpPort();
533             String fileName = cameraUpgradePlan.getUpgradeFileName();
534 
535             //转换监控点信息
536 //            List<Camera> cameraList = cameraDao.getCameraBySyscodes( reCameraSyscode.toArray(new String[reCameraSyscode.size()]));
537             EncoderCondition encoderCondition = new EncoderCondition();
538             encoderCondition.setSysCodeList(reEncoderSyscode);
539             List<Encoder> encoderList = encoderBasicService.fetchList(encoderCondition);
540             Map<Integer,String>> encoderChannalMap = dealWithEncoderChannalForEncoder(encoderList);
541 
542             //封装条件
543             CameraUpgradeDto cameraUpgradeDto = new CameraUpgradeDto();
544             cameraUpgradeDto.setFtpIp(ftpIp);
545             cameraUpgradeDto.setFtpPort(ftpPort);
546             cameraUpgradeDto.setFtpUserName(ftpUser);
547             cameraUpgradeDto.setFtpPsd(ftpPwd);
548             cameraUpgradeDto.setFileName(fileName);
549             String upgradeMessage = toUpgradeEquip(encoderChannalMap,planId);
550             if (upgradeMessage != null && !"".equals(upgradeMessage)) {
551                 throw new RuntimeException(upgradeMessage);
552             } else if (ValidateUtil.isNotEmpty(isUpgradeCamera)) {
553                 throw new RuntimeException("设备" + isUpgradeCamera.substring(0,isUpgradeCamera.length() - 1) + "正在升级中，请勿重复下发！");
554             }
555         }
556 
557     }
558 
559     /**
560      * 处理升级完成报警
561      */
562     public void updateCameraStatusByAlarmEvent(List<Event> events) {
563         for (Event event : events) {
564             int eventType = event.getEventType();
565             if (ConstparamEventType.EVENT_TYPE_UPDATE_RESULT == eventType) {
566                 String alarmContent = event.getExtInfo();
567                 LogUtils.logInfo("ehome接入处理远程升级状态返回报文，mq返回报文：" + alarmContent);
568                 if (!ValidateUtil.isNull(alarmContent)) {
569                     //将文件转换成xml
570                     alarmContent =  alarmContent.replace("<EventNotificationAlert version="1.0" xmlns="http://www.hikvision.com/ver20/XMLSchema">","<ExtEventInfo>").replace("</EventNotificationAlert>","</ExtEventInfo>");
571 
572                     CameraUpgradeResultXml resultXml = XmlUtil.unMarshaller(CameraUpgradeResultXml.class,alarmContent);
573                     CameraUpgradeResultDetailXml resultDetailXml = resultXml.getUpdateResult();
574                     String devIndex = resultXml.getDeviceId();
575                     Integer channelId = resultDetailXml.getChannelID();
576                     //根据devIndex 和通道号查出相应的监控点 之后进行状态的更新
577                     Integer errorCode = resultDetailXml.getErrorCode();
578                     if (errorCode == 0) {
579                         //升级成功 将设置成升级成功状态
580                         //根据记录的ID去更新status 为升级成功。
581                         cameraUpgradeDao.updateCameraStatusByEncoderSyscodeAndChannelIdForEvent(devIndex,channelId,UPDATE_COMPLETE,null);
582                     } else {
583                         String errorDes = resultDetailXml.getErrorMsg();
584                         LogUtils.logInfo("设备升级设备，DevIndexCode:" + devIndex + ";通道号：" + channelId + "。错误描述：" + errorDes);
585                         cameraUpgradeDao.updateCameraStatusByEncoderSyscodeAndChannelIdForEvent(devIndex,UPDATE_FAIL,errorDes);
586                         //更新升级的设备状态为错误
587                     }
588                 }
589             }
590         }
591     }
592 }

package com.hikvision.cms.vss.biz.res.respoint.camera.dto.cfg;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

/**
 * 远程升级结果返回报文
 * author lixin24
 * date 2018-07-20
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "ExtEventInfo")
public class CameraUpgradeResultXml {
    /**
     * 报警设备IPV4地址
     */
    @XmlElement(name = "ipAddress")
    private String ipAddress;

    /**
     * 报警设备IPV6地址
     */
    @XmlElement(name = "ipv6Address")
    private String ipv6Address;

    /**
     *报警设备端口号
     */
    @XmlElement(name = "portNo")
    private int portNo;

    /**
     * 报警设备端口号
     */
    @XmlElement(name = "macAddress")
    private String macAddress;

    /**
     * 报警时间
     */
    @XmlElement(name = "dateTime")
    private String dateTime;

    /**
     * 同一个报警上传的次数
     */
    @XmlElement(name = "activePostCount")
    private int activePostCount;

    /**
     * 触发的事件类型
     */
    @XmlElement(name = "eventType")
    private String eventType;

    /**
     * 事件触发状态: active-触发,inactive-未触发(表示心跳数据)
     */
    @XmlElement(name = "eventState")
    private String eventState;

    /**
     * 事件状态
     */
    @XmlElement(name = "eventDescription")
    private String eventDescription;

    @XmlElement(name = "deviceID")
    private String deviceId;
    /**
     * 结果报警信息
     */
    @XmlElement(name = "updateResult")
    private CameraUpgradeResultDetailXml updateResult;

    public CameraUpgradeResultXml() {
    }

    public String getDeviceId() {
        return deviceId;
    }

    public void setDeviceId(String deviceId) {
        this.deviceId = deviceId;
    }

    public String getIpAddress() {
        return ipAddress;
    }

    public void setIpAddress(String ipAddress) {
        this.ipAddress = ipAddress;
    }

    public String getIpv6Address() {
        return ipv6Address;
    }

    public void setIpv6Address(String ipv6Address) {
        this.ipv6Address = ipv6Address;
    }

    public int getPortNo() {
        return portNo;
    }

    public void setPortNo(int portNo) {
        this.portNo = portNo;
    }

    public String getMacAddress() {
        return macAddress;
    }

    public void setMacAddress(String macAddress) {
        this.macAddress = macAddress;
    }

    public String getDateTime() {
        return dateTime;
    }

    public void setDateTime(String dateTime) {
        this.dateTime = dateTime;
    }

    public int getActivePostCount() {
        return activePostCount;
    }

    public void setActivePostCount(int activePostCount) {
        this.activePostCount = activePostCount;
    }

    public String getEventType() {
        return eventType;
    }

    public void setEventType(String eventType) {
        this.eventType = eventType;
    }

    public String getEventState() {
        return eventState;
    }

    public void setEventState(String eventState) {
        this.eventState = eventState;
    }

    public String getEventDescription() {
        return eventDescription;
    }

    public void setEventDescription(String eventDescription) {
        this.eventDescription = eventDescription;
    }

    public CameraUpgradeResultDetailXml getUpdateResult() {
        return updateResult;
    }

    public void setUpdateResult(CameraUpgradeResultDetailXml updateResult) {
        this.updateResult = updateResult;
    }
}

/**
 * @ProjectName: 智能楼宇
 * @Copyright: 2012 HangZhou Hikvision System Technology Co.,Ltd. All Right Reserved.
 * @address: http://www.hikvision.com
 * @date: 2015年3月31日 下午1:37:10
 * @Description: 本内容仅限于杭州海康威视数字技术系统公司内部使用，禁止转发.
 */
package com.hikvision.cms.common.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;

/**
 * <p>
 * </p>
 * 
 * @author xupengpeng 2015年3月31日 下午1:37:10
 * @version V1.0
 * @modificationHistory=========================逻辑或功能性重大变更记录
 * @modify by user: {修改人} 2015年3月31日
 * @modify by reason:{方法名}:{原因}
 */
public class XmlUtil {
    /**
     * 创建一个新的实例XmlUtil.
     */
    private XmlUtil() {
    }

    /**
     * 生成Xml
     * 
     * @author fanxunfeng 2014年5月15日 上午9:03:00
     * @param object
     *            需翻译对象
     * @return Xml字符串
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2014年5月15日
     * @modify by reason:{原因}
     */
    public static String toXml(Object object) {
        String result = toXml(object,"GBK");
        result = result.replace("encoding="GBK"","encoding="UTF-8"");
        return result;
    }

    /**
     * 生成Xml
     * 
     * @author fanxunfeng 2014年5月15日 上午9:03:00
     * @param object
     *            需翻译对象
     * @return Xml字符串
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2014年5月15日
     * @modify by reason:{原因}
     */
    public static String toXml(Object object,String code) {
        String result = "";
        OutputStream out = new ByteArrayOutputStream();
        try {
            JAXBContext context = JAXBContext.newInstance(object.getClass());
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING,code);
            marshaller.marshal(object,out);
            result = out.toString().replace(" standalone="yes"","");
        } catch (Exception e) {
            throw new UnsupportedOperationException(e);
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                throw new UnsupportedOperationException(e);
            }
        }
        return result;
    }

    /**
     * 将xml反解析成对应的类
     * 
     * @author fanxunfeng 2014年5月15日 上午9:03:11
     * @param <T>
     *            解析类
     * @param cls
     *            类类型
     * @param protocol
     *            xml内容
     * @return 类类型对应的实例对象
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2014年5月15日
     * @modify by reason:{原因}
     */
    public static <T> T unMarshaller(Class<T> cls,String protocol) {
        return unMarshaller(cls,protocol,"UTF-8");
    }
    
    @SuppressWarnings("unchecked")
    public static <T> T fromXML(String xml,Class<T> valueType) {
        try {
            JAXBContext context = JAXBContext.newInstance(valueType);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            return (T) unmarshaller.unmarshal(new StringReader(xml));
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }

    /**
     * 将xml反解析成对应的类
     * 
     * @author fanxunfeng 2014年5月15日 上午9:03:11
     * @param <T>
     *            解析类
     * @param cls
     *            类类型
     * @param protocol
     *            xml内容
     * @return 类类型对应的实例对象
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2014年5月15日
     * @modify by reason:{原因}
     */
    @SuppressWarnings("unchecked")
    public static <T> T unMarshaller(Class<T> cls,String protocol,String code) {
        T t = null;
        InputStream is = null;
        try {
            is = new ByteArrayInputStream(protocol.getBytes(code));
            JAXBContext context = JAXBContext.newInstance(cls);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            t = (T) unmarshaller.unmarshal(is);
        } catch (Exception e) {
            throw new UnsupportedOperationException(e);
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    throw new UnsupportedOperationException(e);
                }
            }
        }
        return t;
    }

    public static String format(String unformattedXml) {
        try {
            final Document document = parseXmlFile(unformattedXml);
            OutputFormat format = new OutputFormat(document);
            format.setLineWidth(65);
            format.setIndenting(true);
            format.setIndent(2);
            Writer out = new StringWriter();
            XMLSerializer serializer = new XMLSerializer(out,format);
            serializer.serialize(document);
            return out.toString();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static Document parseXmlFile(String in) {
        try {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            InputSource is = new InputSource(new StringReader(in));
            return db.parse(is);
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(e);
        } catch (SAXException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.hikvision.cms.util.frame.xmlanalyze;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;

public final class XmlUtil {
    private XmlUtil() {
    }

    public static String toXml(Object object) {
        String result = toXml(object,"encoding="UTF-8"");
        return result;
    }

    public static String toXml(Object object,String code) {
        String result = "";
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        try {
            Result rs = new StreamResult(out);
            JAXBContext context = JAXBContext.newInstance(object.getClass());
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty("jaxb.encoding",rs);
            result = new String(out.toByteArray(),"GBK");
            result = result.replace(" standalone="yes"","");
            result = new String(result.getBytes("UTF-8"),"ISO-8859-1");
            result = new String(result.getBytes("ISO-8859-1"),"UTF-8");
        } catch (Exception var14) {
            throw new UnsupportedOperationException(var14);
        } finally {
            try {
                out.close();
            } catch (IOException var13) {
                throw new UnsupportedOperationException(var13);
            }
        }

        return result;
    }

    public static <T> T unMarshaller(Class<T> cls,"UTF-8");
    }

    public static <T> T unMarshaller(Class<T> cls,String code) {
        T t = null;
        ByteArrayInputStream is = null;

        try {
            is = new ByteArrayInputStream(protocol.getBytes(code));
            JAXBContext context = JAXBContext.newInstance(cls);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            t = unmarshaller.unmarshal(is);
        } catch (Exception var14) {
            throw new UnsupportedOperationException(var14);
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException var13) {
                    throw new UnsupportedOperationException(var13);
                }
            }

        }

        return t;
    }
}