From 64efb660b2c119c00432434c0f651f8996483f18 Mon Sep 17 00:00:00 2001 From: fuliqi <fuliqi@qq.com> Date: 星期五, 21 二月 2025 15:51:13 +0800 Subject: [PATCH] OSD大华数据格式+数据中心重点标签统计数 --- ycl-server/src/main/java/com/ycl/platform/service/impl/YwThresholdServiceImpl.java | 695 ++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 files changed, 605 insertions(+), 90 deletions(-) diff --git a/ycl-server/src/main/java/com/ycl/platform/service/impl/YwThresholdServiceImpl.java b/ycl-server/src/main/java/com/ycl/platform/service/impl/YwThresholdServiceImpl.java index 6eca6d8..8a19b35 100644 --- a/ycl-server/src/main/java/com/ycl/platform/service/impl/YwThresholdServiceImpl.java +++ b/ycl-server/src/main/java/com/ycl/platform/service/impl/YwThresholdServiceImpl.java @@ -1,36 +1,77 @@ package com.ycl.platform.service.impl; -import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper; +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.context.AnalysisContext; +import com.alibaba.excel.event.AnalysisEventListener; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.fastjson2.JSONArray; +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; -import com.ycl.platform.domain.dto.CarDTO; -import com.ycl.platform.domain.dto.FaceDTO; -import com.ycl.platform.domain.dto.VideoDTO; +import com.ycl.dataListener.CurrencyDataListener; +import com.ycl.platform.domain.entity.WorkOrder; +import com.ycl.platform.domain.entity.WorkOrderWhite; +import com.ycl.platform.domain.entity.YwPoint; import com.ycl.platform.domain.entity.YwThreshold; -import com.ycl.platform.domain.form.CarThresholdForm; -import com.ycl.platform.domain.form.FaceThresholdForm; -import com.ycl.platform.domain.form.VideoThresholdForm; +import com.ycl.platform.domain.excel.ErrorExport; +import com.ycl.platform.domain.excel.PointExport; +import com.ycl.platform.domain.excel.WorkOrderWhiteExport; +import com.ycl.platform.domain.query.WorkOrderWhiteQuery; +import com.ycl.platform.domain.result.HK.FaceDeviceInspectionResult; +import com.ycl.platform.domain.result.HK.VehicleDeviceInspectionResult; +import com.ycl.platform.domain.vo.DynamicColumnVO; +import com.ycl.platform.mapper.WorkOrderWhiteMapper; import com.ycl.platform.mapper.YwThresholdMapper; import com.ycl.platform.service.IYwThresholdService; -import com.ycl.utils.DateUtils; +import com.ycl.platform.service.WorkOrderService; +import com.ycl.system.Result; +import com.ycl.system.page.PageUtil; +import com.ycl.utils.SecurityUtils; +import com.ycl.utils.StringUtils; +import com.ycl.utils.ip.PingUtil; +import com.ycl.utils.poi.EasyExcelImportUtils; +import com.ycl.utils.uuid.IdUtils; +import constant.PointHeaderConstant; +import constant.YwThreadConstants; +import enumeration.CompareType; +import enumeration.ErrorType; import enumeration.general.BusinessTypeEnum; -import lombok.RequiredArgsConstructor; -import org.springframework.beans.BeanUtils; +import enumeration.general.WorkOrderStatusEnum; +import jakarta.servlet.http.HttpServletResponse; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.CollectionUtils; +import org.springframework.web.multipart.MultipartFile; +import utils.DateUtils; -import java.util.List; -import java.util.Objects; +import java.io.IOException; +import java.io.OutputStream; +import java.util.*; +import java.util.concurrent.ExecutionException; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.stream.Collectors; /** * 杩愮淮闃堝�糞ervice涓氬姟灞傚鐞� * * @author gonghl - * @date 2024-03-25 + * @date 2024-07-19 */ @Service -@RequiredArgsConstructor +@Slf4j public class YwThresholdServiceImpl extends ServiceImpl<YwThresholdMapper, YwThreshold> implements IYwThresholdService { + @Autowired + private YwThresholdMapper ywThresholdMapper; - private final YwThresholdMapper ywThresholdMapper; + @Autowired + private WorkOrderService workOrderService; + + @Autowired + private WorkOrderWhiteMapper workOrderWhiteMapper; /** * 鏌ヨ杩愮淮闃堝�� @@ -39,7 +80,7 @@ * @return 杩愮淮闃堝�� */ @Override - public YwThreshold selectYwThresholdById(Integer id) { + public YwThreshold selectYwThresholdById(Long id) { return ywThresholdMapper.selectYwThresholdById(id); } @@ -50,8 +91,10 @@ * @return 杩愮淮闃堝�� */ @Override - public List<YwThreshold> selectYwThresholdList(YwThreshold ywThreshold) { - return ywThresholdMapper.selectYwThresholdList(ywThreshold); + public Map<String, List<YwThreshold>> selectYwThresholdList(YwThreshold ywThreshold) { + List<YwThreshold> ywThresholds = ywThresholdMapper.selectYwThresholdList(ywThreshold); + Map<String, List<YwThreshold>> map = ywThresholds.stream().collect(Collectors.groupingBy(YwThreshold::getMonitorType)); + return map; } /** @@ -69,13 +112,13 @@ /** * 淇敼杩愮淮闃堝�� * - * @param ywThreshold 杩愮淮闃堝�� + * @param list 杩愮淮闃堝�� * @return 缁撴灉 */ @Override - public int updateYwThreshold(YwThreshold ywThreshold) { - ywThreshold.setUpdateTime(DateUtils.getNowDate()); - return ywThresholdMapper.updateYwThreshold(ywThreshold); + public Boolean updateYwThreshold(List<YwThreshold> list) { + list.forEach(item -> item.setCreateTime(new Date())); + return updateBatchById(list); } /** @@ -85,7 +128,7 @@ * @return 缁撴灉 */ @Override - public int deleteYwThresholdByIds(Integer[] ids) { + public int deleteYwThresholdByIds(Long[] ids) { return ywThresholdMapper.deleteYwThresholdByIds(ids); } @@ -96,105 +139,577 @@ * @return 缁撴灉 */ @Override - public int deleteYwThresholdById(Integer id) { + public int deleteYwThresholdById(Long id) { return ywThresholdMapper.deleteYwThresholdById(id); } + /** + * 鍒ゆ柇瑙嗛闃堝�兼槸鍚︽弧瓒充笅鍙戞潯浠� + * + * @param list + */ @Override - public int editFace(FaceThresholdForm form) { - YwThreshold ywThreshold = baseMapper.selectById(form.getId()); - if (Objects.isNull(ywThreshold)) { - throw new RuntimeException("鏁版嵁涓嶅瓨鍦�"); + public void videoCheck(List list) { + } + + @Override + public void errorTypeCheckUY(List list) { + // 骞冲彴绂荤嚎鏁呴殰妫�娴� + if (CollectionUtils.isEmpty(list)) { + Boolean ping = PingUtil.ping("", 5); + if (!ping) { + + } } - BeanUtils.copyProperties(form, ywThreshold); -// ywThreshold.setIndicator(JSON.toJSONString(form)); - return baseMapper.updateById(ywThreshold); + // 璁惧绂荤嚎鏁呴殰妫�娴� + + // 淇″彿缂哄け鏁呴殰妫�娴� + + // 鐢婚潰鍋忚壊鏁呴殰妫�娴� + + // 闆姳骞叉壈鏁呴殰妫�娴� + + // 鏉$汗骞叉壈鏁呴殰妫�娴� + + // 鐢婚潰閬尅鏁呴殰妫�娴� + + // 娓呮櫚搴﹀紓甯告娴� + + // 浜害寮傚父鏁呴殰妫�娴� } + /** + * 鍒ゆ柇浜鸿劯闃堝�兼槸鍚︽弧瓒充笅鍙戞潯浠� + * + * @param list + */ @Override - public int editCar(CarThresholdForm form) { - YwThreshold ywThreshold = baseMapper.selectById(form.getId()); - if (Objects.isNull(ywThreshold)) { - throw new RuntimeException("鏁版嵁涓嶅瓨鍦�"); + public void faceCheck(List<FaceDeviceInspectionResult> list) { + Map<String, YwThreshold> thresholdMap = getYwThresholdMap(BusinessTypeEnum.FACE.name()); + //鍑嗗寰呬笅鍙戝伐鍗曢泦鍚� + List<WorkOrder> distributeList = new ArrayList<>(); + //鍑嗗鐩存帴涓嬪彂宸ュ崟闆嗗悎 + List<WorkOrder> workOrderList = new ArrayList<>(); + //澶勭悊鎺ュ彛鏁版嵁 + for (FaceDeviceInspectionResult result : list) { + if (result == null) { + log.error("浜鸿劯瀵硅薄鏁版嵁涓虹┖"); + continue; + } + WorkOrder workOrder = new WorkOrder(); + //妫�鏌ユ椂閽熷噯纭巼 + if (result.getSnapClock() != null) { + Float clockPercent = result.getSnapClock().getClockPercent(); + check(YwThreadConstants.Face_ClockPercent, clockPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CLOCK_RIGHT.getValue()); + } + //妫�鏌ユ暟鎹強鏃剁巼 + if (result.getSnapTimely() != null) { + Float timelyPercent = result.getSnapTimely().getTimelyPercent(); + check(YwThreadConstants.Face_TimelyPercent, timelyPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.DATA_TIMELY_ERROR.getValue()); + } + //妫�鏌ユ寔缁棤鏁版嵁澶╂暟 + if (result.getContinueNoDataCount() != null) { + Integer continueNoDataCount = result.getContinueNoDataCount(); + check(YwThreadConstants.Face_ContinueNoDataCount, continueNoDataCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.LONG_DAY_NO_DATA.getValue()); + } + //妫�鏌ヤ笉鍞竴鏁版嵁閲� + if (result.getSnapUnique() != null) { + Integer nouniqueCount = result.getSnapUnique().getNouniqueCount(); + check(YwThreadConstants.Face_NouniqueCount, nouniqueCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.NOT_UNIQUE_DATA_VOLUME.getValue()); + } + //妫�鏌ヤ汉鑴镐綆璇勫垎鐜� + if (result.getSnapValidity() != null) { + Float lowScorePercent = result.getSnapValidity().getLowScorePercent(); + check(YwThreadConstants.Face_LowScorePercent, lowScorePercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.FACE_LOW.getValue()); + } + //妫�鏌ュ缓妯″け璐ョ巼 + if (result.getSnapValidity() != null) { + Float failPercent = result.getSnapValidity().getFailPercent(); + check(YwThreadConstants.Face_FailPercent, failPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.MODELING_FAIL.getValue()); + } + // 鐐逛綅鍦ㄧ嚎鐜� +// if (2 == result.getSnapResult()) { +// workOrder.setSerialNumber(result.getExternalIndexCode()); +// workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED); +// if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) { +// workOrder.setErrorTypeList(new ArrayList<>()); +// workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue()); +// } else { +// workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue()); +// } +// } + if (WorkOrderStatusEnum.WAIT_DISTRIBUTE.equals(workOrder.getStatus())) { + workOrderList.add(workOrder); + } else if (WorkOrderStatusEnum.DISTRIBUTED.equals(workOrder.getStatus())) { + distributeList.add(workOrder); + } } - BeanUtils.copyProperties(form, ywThreshold); -// ywThreshold.setIndicator(JSON.toJSONString(form)); - return baseMapper.updateById(ywThreshold); + /** 娣诲姞宸ュ崟 */ + workOrderService.innerAddWorkOrder(workOrderList); + workOrderService.innerAddWorkOrder(distributeList); } + /** + * 鍒ゆ柇杞﹁締闃堝�兼槸鍚︽弧瓒充笅鍙戞潯浠� + * + * @param list + */ @Override - public int editVideo(VideoThresholdForm form) { - YwThreshold ywThreshold = baseMapper.selectById(form.getId()); - if (Objects.isNull(ywThreshold)) { - throw new RuntimeException("鏁版嵁涓嶅瓨鍦�"); + public void carCheck(List<VehicleDeviceInspectionResult> list) { + Map<String, YwThreshold> thresholdMap = getYwThresholdMap(BusinessTypeEnum.CAR.name()); + //鍑嗗涓嬪彂宸ュ崟闆嗗悎 + List<WorkOrder> distributeList = new ArrayList<>(); + //鍑嗗鑷姩鐢熸垚宸ュ崟闆嗗悎 + List<WorkOrder> workOrderList = new ArrayList<>(); + //澶勭悊鎺ュ彛鏁版嵁 + for (VehicleDeviceInspectionResult result : list) { + if (result == null) { + log.error("杞﹁締瀵硅薄鏁版嵁涓虹┖"); + continue; + } + WorkOrder workOrder = new WorkOrder(); + //妫�鏌ユ寔缁棤鏁版嵁澶╂暟 + Integer continueNoDataCount = result.getContinueNoDataCount(); + check(YwThreadConstants.Car_ContinueNoDataCount, continueNoDataCount, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.LONG_DAY_NO_DATA.getValue()); + //妫�鏌ユ椂閽熷噯纭巼 + if (result.getSnapClock() != null) { + Float clockPercent = result.getSnapClock().getClockPercent(); + check(YwThreadConstants.Car_ClockPercent, clockPercent, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CLOCK_RIGHT.getValue()); + } + //妫�鏌ユ暟鎹強鏃剁巼 + if (result.getSnapTimely() != null) { + Float timelyPercentResult = result.getSnapTimely().getTimelyPercent(); + check(YwThreadConstants.Car_TimelyPercent, timelyPercentResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.DATA_TIMELY_ERROR.getValue()); + } + //妫�鏌ヤ笉鍞竴鏁版嵁閲� + if (result.getSnapUnique() != null) { + Integer nouniqueCountResult = result.getSnapUnique().getNouniqueCount(); + check(YwThreadConstants.Car_NouniqueCount, nouniqueCountResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.NOT_UNIQUE_DATA_VOLUME.getValue()); + } + //妫�鏌ョ櫧澶╂湭璇嗗埆閲� + if (result.getSnapPlate() != null) { + Integer dayNoNumberCountResult = result.getSnapPlate().getDayNoNumberCount(); + check(YwThreadConstants.Car_DayNoNumberCount, dayNoNumberCountResult, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.MORE_THAN_EQ, ErrorType.UNRECOGNIZED_DAY_VOLUME.getValue()); + } + //杞﹁締涓昏灞炴�т竴鑷寸巼 + if (result.getIntegrity() != null) { + Integer noIntegrityCountResult = result.getIntegrity().getMainNoIntegrityCount(); + Integer dataCount = result.getDataCount(); + Double integrityRate = ((double) dataCount - noIntegrityCountResult) / dataCount; + check(YwThreadConstants.Car_NoIntegrityCount, integrityRate, result.getExternalIndexCode(), thresholdMap, workOrder, CompareType.LESS_THAN_EQ, ErrorType.CAR_SIX.getValue()); + } + // 鐐逛綅鍦ㄧ嚎鐜� +// if (2 == result.getSnapResult()) { +// workOrder.setSerialNumber(result.getExternalIndexCode()); +// workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED); +// if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) { +// workOrder.setErrorTypeList(new ArrayList<>()); +// workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue()); +// } else { +// workOrder.getErrorTypeList().add(ErrorType.DEVICE_OFFLINE.getValue()); +// } +// } + if (WorkOrderStatusEnum.WAIT_DISTRIBUTE.equals(workOrder.getStatus())) { + workOrderList.add(workOrder); + } else if (WorkOrderStatusEnum.DISTRIBUTED.equals(workOrder.getStatus())) { + distributeList.add(workOrder); + } } - BeanUtils.copyProperties(form, ywThreshold); -// ywThreshold.setIndicator(JSON.toJSONString(form)); - return baseMapper.updateById(ywThreshold); + /** 娣诲姞宸ュ崟 */ + workOrderService.innerAddWorkOrder(workOrderList); + workOrderService.innerAddWorkOrder(distributeList); + } + /** + * 鎶婇槇鍊兼潯浠舵煡鍑烘潵锛岃浆鎴恗ap + * + * @param name + * @return + */ @Override - public Boolean checkFace(List<FaceDTO> faceList) { - YwThreshold faceEntity = new LambdaQueryChainWrapper<>(baseMapper) - .eq(YwThreshold::getMonitorType, BusinessTypeEnum.FACE) - .one(); - if (Objects.isNull(faceEntity)) { - throw new RuntimeException("璇烽厤缃汉鑴哥殑宸ュ崟闃堝��"); + public Map<String, YwThreshold> getYwThresholdMap(String name) { + return ywThresholdMapper.selectList( + new QueryWrapper<YwThreshold>().eq("monitor_type", name) + ).stream().collect(Collectors.toMap( + YwThreshold::getKey, + Function.identity() + )); + } + + /** + * 鐧藉悕鍗曡鎯� + * + * @param id + * @return + */ + @Override + public Result selectWorkOrderWhiteDetail(Integer id) { + WorkOrderWhite workOrderWhite = workOrderWhiteMapper.getById(id); + List<String> errorTypeList = Arrays.asList(workOrderWhite.getErrorType().split(",")); + workOrderWhite.setErrorTypeList(errorTypeList); + return Result.ok().data(workOrderWhite); + } + + /** + * 宸ュ崟鐧藉悕鍗曞垪琛� + * + * @param query 鏌ヨ + * @return {@link List }<{@link WorkOrderWhite }> + * @author + */ + @Override + public Result selectWorkOrderWhiteList(WorkOrderWhiteQuery query) { + IPage<WorkOrderWhite> page = PageUtil.getPage(query, WorkOrderWhite.class); + workOrderWhiteMapper.page(page, query); + List<WorkOrderWhite> records = page.getRecords(); + records.forEach(white -> { + List<String> errorTextList = new ArrayList<>(); + List<String> errorTypeList = Arrays.asList(white.getErrorType().split(",")); + errorTypeList.forEach(error -> { + String errorText = ErrorType.getDescriptionByValue(error); + errorTextList.add(errorText); + }); + white.setErrorType(String.join(",", errorTextList)); + }); + return Result.ok().data(records).total(page.getTotal()); + } + + /** + * 娣诲姞宸ュ崟鐧藉悕鍗� + * + * @param workOrderWhite 鐧借壊宸ュ崟 + * @return {@link Result } + * @author + */ + @Override + public Result addWorkOrderWhite(WorkOrderWhite workOrderWhite) { + // 妫�鏌ユ槸鍚﹀凡缁忓瓨鍦ㄨ鐧藉悕鍗� + WorkOrderWhite flag = workOrderWhiteMapper.selectBySerialNumber(workOrderWhite.getSerialNumber()); + if (flag != null) { + return Result.error("璇ヨ澶囧凡瀛樺湪鐧藉悕鍗�"); + } else { + List<String> errorTypeList = workOrderWhite.getErrorTypeList(); + workOrderWhite.setErrorType(String.join(",", errorTypeList)); + workOrderWhite.setCreateBy(SecurityUtils.getUsername()); + workOrderWhiteMapper.insert(workOrderWhite); + return Result.ok(); } - // todo 閬嶅巻鏉′欢锛岀敓鎴愬伐鍗� - return Boolean.FALSE; } + /** + * 淇敼宸ュ崟鐧藉悕鍗� + * + * @param workOrderWhite 鐧借壊宸ュ崟 + * @return {@link Result } + * @author + */ @Override - public Boolean checkCar(List<CarDTO> faceList) { - YwThreshold carEntity = new LambdaQueryChainWrapper<>(baseMapper) - .eq(YwThreshold::getMonitorType, BusinessTypeEnum.CAR) - .one(); - if (Objects.isNull(carEntity)) { - throw new RuntimeException("璇烽厤缃溅杈嗙殑宸ュ崟闃堝��"); + public Result updateWorkOrderWhite(WorkOrderWhite workOrderWhite) { + WorkOrderWhite white = workOrderWhiteMapper.selectBySerialNumber(workOrderWhite.getSerialNumber()); + workOrderWhite.setId(white.getId()); + List<String> errorTypeList = workOrderWhite.getErrorTypeList(); + workOrderWhite.setErrorType(String.join(",", errorTypeList)); + workOrderWhiteMapper.updateById(workOrderWhite); + return Result.ok(); + } + + /** + * 鎵归噺鍒犻櫎宸ュ崟鐧藉悕鍗� + * + * @param ids ids + * @author + */ + @Override + public Result batchDeleteWorkOrderWhite(List<String> ids) { + workOrderWhiteMapper.batchDelete(ids); + return Result.ok(); + } + + /** + * 鐧藉悕鍗曞鍑� + * + * @param response + * @throws IOException + */ + @Override + public void whiteExport(HttpServletResponse response) throws IOException { + //鐧藉悕鍗曟暟鎹� + List<WorkOrderWhiteExport> data = workOrderWhiteMapper.whiteExport(); + data.forEach(white -> { + List<String> errorTextList = new ArrayList<>(); + List<String> errorTypeList = Arrays.asList(white.getErrorType().split(",")); + errorTypeList.forEach(error -> { + String errorText = ErrorType.getDescriptionByValue(error); + errorTextList.add(errorText); + }); + white.setErrorType(String.join(",", errorTextList)); + }); + //鏁呴殰绫诲瀷鏁版嵁 + List<String> errorTextList = ErrorType.getDescriptionList(); + List<ErrorExport> errorExports = new ArrayList<>(); + errorTextList.forEach(error -> { + ErrorExport errorExport = new ErrorExport(); + errorExport.setError(error); + errorExports.add(errorExport); + }); + ExcelWriter excelWriter = null; + try (OutputStream outputStream = response.getOutputStream()) { + excelWriter = EasyExcel.write(outputStream).build(); + + WriteSheet whiteSheet = EasyExcel.writerSheet(0, "宸ュ崟鐧藉悕鍗曟竻鍗�").head(WorkOrderWhiteExport.class).build(); + WriteSheet errorSheet = EasyExcel.writerSheet(1, "鏁呴殰绫诲瀷").head(ErrorExport.class).build(); + + excelWriter.write(data, whiteSheet); + excelWriter.write(errorExports, errorSheet); + excelWriter.finish(); + outputStream.flush(); + } catch (Exception e) { + e.printStackTrace(); + } finally { + try { + excelWriter.finish(); + response.getOutputStream().close(); + } catch (IOException e) { + e.printStackTrace(); + } } - // todo 閬嶅巻鏉′欢锛岀敓鎴愬伐鍗� - return Boolean.FALSE; + } + /** + * 瀵煎叆宸ュ崟鐧藉悕鍗� + * + * @param file + * @return + */ @Override - public Boolean checkVideo(List<VideoDTO> faceList) { - YwThreshold videoEntity = new LambdaQueryChainWrapper<>(baseMapper) - .eq(YwThreshold::getMonitorType, BusinessTypeEnum.VIDEO) - .one(); - if (Objects.isNull(videoEntity)) { - throw new RuntimeException("璇烽厤缃棰戠殑宸ュ崟闃堝��"); + @Transactional(rollbackFor = Exception.class) + public Result importWhite(MultipartFile file) throws IOException { +// Consumer<List<WorkOrderWhiteExport>> consumer = (dataList) -> { +// try { +// this.updateWhite(dataList); +// } catch (ExecutionException e) { +// e.printStackTrace(); +// } catch (InterruptedException e) { +// e.printStackTrace(); +// } +// }; +// EasyExcel.read(file.getInputStream(), WorkOrderWhiteExport.class, new CurrencyDataListener(consumer)) +// .sheet() +// .headRowNumber(1) +// .doRead(); + List<WorkOrderWhiteExport> dataList = new ArrayList<>(); + EasyExcel.read(file.getInputStream(), WorkOrderWhiteExport.class, new AnalysisEventListener<WorkOrderWhiteExport>() { + @Override + public void invoke(WorkOrderWhiteExport excel, AnalysisContext analysisContext) { + // 灏嗚鍙栧埌鐨勬瘡涓�琛屽瓨鍏eportDetails闆嗗悎涓� + dataList.add(excel); + } + + @Override + public void doAfterAllAnalysed(AnalysisContext analysisContext) { + } + }).sheet().doRead(); + + if (CollectionUtils.isEmpty(dataList)) { + throw new RuntimeException("瀵煎叆鏁版嵁涓嶈兘涓虹┖"); } - // todo 閬嶅巻鏉′欢锛岀敓鎴愬伐鍗� - return Boolean.FALSE; + boolean duplic = checkDuplic(dataList); + if (duplic) throw new RuntimeException("瀛樺湪閲嶅鍥芥爣璁惧"); + List<WorkOrderWhite> addList = new ArrayList<>(); + dataList.stream().forEach(item -> { + WorkOrderWhite white = new WorkOrderWhite(); + //鍥芥爣鐮� + white.setSerialNumber(item.getSerialNumber()); + //澶囨敞 + white.setRemark(item.getRemark()); + String errorType = item.getErrorType(); + if (StringUtils.isEmpty(errorType)) { + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滀笉鑳戒负绌�"); + } + try { + List<String> errorDataList = new ArrayList<>(); + List<String> errorExcelList = Arrays.asList(item.getErrorType().split(",")); + errorExcelList.forEach(desc -> { + //鎶婁腑鏂囪浆鎹负鏁版嵁搴撳瓨鍌ㄦ牸寮� + String errorText = ErrorType.getValueByDescription(desc); + //鎵句笉鍒版姏鍑哄紓甯� + if (errorText == null) + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滅被鍨嬫湁璇�"); + errorDataList.add(errorText); + }); + white.setErrorType(String.join(",", errorDataList)); + addList.add(white); + } catch (Exception e) { + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滅被鍨嬫湁璇�"); + } + }); + if (!CollectionUtils.isEmpty(addList)) { + workOrderWhiteMapper.deleteAll(); + workOrderWhiteMapper.insertBatch(addList); + } + return Result.ok(); } - @Override - public FaceThresholdForm getFace(Integer id) { - return null; + /** + * 淇敼鐧藉悕鍗� + * + * @param dataList + * @param unitId + */ + public void updateWhite(List<WorkOrderWhiteExport> dataList) throws ExecutionException, InterruptedException { + if (CollectionUtils.isEmpty(dataList)) { + throw new RuntimeException("瀵煎叆鏁版嵁涓嶈兘涓虹┖"); + } + //宸插瓨鍦ㄧ殑鐧藉悕鍗� + List<String> serialNumbers = workOrderWhiteMapper.selectList().stream().map(WorkOrderWhite::getSerialNumber).collect(Collectors.toList()); + List<WorkOrderWhite> addList = new ArrayList<>(); + List<WorkOrderWhite> updateList = new ArrayList<>(); + dataList.stream().forEach(item -> { + WorkOrderWhite white = new WorkOrderWhite(); + //鍥芥爣鐮� + white.setSerialNumber(item.getSerialNumber()); + //澶囨敞 + white.setRemark(item.getRemark()); + String errorType = item.getErrorType(); + if (StringUtils.isEmpty(errorType)) { + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滀笉鑳戒负绌�"); + } + try { + List<String> errorDataList = new ArrayList<>(); + List<String> errorExcelList = Arrays.asList(item.getErrorType().split(",")); + errorExcelList.forEach(desc -> { + //鎶婁腑鏂囪浆鎹负鏁版嵁搴撳瓨鍌ㄦ牸寮� + String errorText = ErrorType.getValueByDescription(desc); + //鎵句笉鍒版姏鍑哄紓甯� + if (errorText == null) + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滅被鍨嬫湁璇�"); + errorDataList.add(errorText); + }); + white.setErrorType(String.join(",", errorDataList)); + if (!CollectionUtils.isEmpty(serialNumbers) && serialNumbers.contains(white.getSerialNumber())) { + updateList.add(white); + } else { + addList.add(white); + } + } catch (Exception e) { + throw new RuntimeException("鍥芥爣鐮佷负" + item.getSerialNumber() + "鐨勮澶囨晠闅滅被鍨嬫湁璇�"); + } + }); + if (!CollectionUtils.isEmpty(addList)) workOrderWhiteMapper.insertBatch(addList); + if (!CollectionUtils.isEmpty(updateList)) workOrderWhiteMapper.updateBatch(updateList); } + /** + * 妫�鏌ラ槇鍊� + * + * @param key 鏌愰槇鍊兼爣璇� + * @param value 鎺ュ彛鑾峰彇鍒扮殑鍊� + * @param serialNumber 鍥芥爣鐮� + * @param thresholds 闃堝�兼潯浠秏ap + * @param compareType 姣旇緝鏂瑰紡锛�>= <= + * @param errorType 鏁呴殰绫诲瀷 + * @param <T> + */ @Override - public CarThresholdForm getCar(Integer id) { - return null; + public <T extends Comparable<T>> void check(String key, T value, String + serialNumber, Map<String, YwThreshold> thresholds, WorkOrder workOrder, CompareType compareType, String + errorType) { + Optional.ofNullable(value).ifPresentOrElse( + v -> { + YwThreshold ywThreshold = thresholds.get(key); + //杞崲绫诲瀷 + //寰呭伐鍗曢槇鍊� + T thresholdAutoValue = parseThreshold(ywThreshold.getValueAuto(), value.getClass()); + //鐩存帴涓嬪彂宸ュ崟闃堝�� + T thresholdValue = parseThreshold(ywThreshold.getValue(), value.getClass()); + if ("percent".equals(ywThreshold.getCountType())) { + if (thresholdAutoValue instanceof Float) { + thresholdAutoValue = (T) Float.valueOf(((Float) thresholdAutoValue) / 100f); + } + if (thresholdValue instanceof Float) { + thresholdValue = (T) Float.valueOf(((Float) thresholdValue) / 100f); + } + } + //姣旇緝澶у皬锛屽姞鍏ュ埌瀵瑰簲寰呭鐞嗛泦鍚� + if (compareType.compare(v, thresholdValue)) { + //杩涘叆宸ュ崟鐩存帴涓嬪彂 + workOrder.setSerialNumber(serialNumber); + workOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED); + if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) { + workOrder.setErrorTypeList(new ArrayList<>()); + workOrder.getErrorTypeList().add(errorType); + } else { + workOrder.getErrorTypeList().add(errorType); + } + } else if (compareType.compare(v, thresholdAutoValue)) { + //杩涘叆宸ュ崟浠d笅鍙� + workOrder.setSerialNumber(serialNumber); + workOrder.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE); + if (CollectionUtils.isEmpty(workOrder.getErrorTypeList())) { + workOrder.setErrorTypeList(new ArrayList<>()); + workOrder.getErrorTypeList().add(errorType); + } else { + workOrder.getErrorTypeList().add(errorType); + } + } + }, + () -> log.error("{} 涓虹┖: {}", thresholds.get(key).getName(), serialNumber) + ); } + /** + * 鎵�鏈夌櫧鍚嶅崟娣诲姞鏁呴殰绫诲瀷 + * + * @param workOrderWhite + */ @Override - public VideoThresholdForm getVideo(Integer id) { - YwThreshold result = new LambdaQueryChainWrapper<>(baseMapper) - .select(YwThreshold::getImageQuality, - YwThreshold::getId, - YwThreshold::getMonitorType, - YwThreshold::getImageQualityAuto, - YwThreshold::getVideoQuality, - YwThreshold::getVideoQualityAuto, - YwThreshold::getAnnotationAccuracy, - YwThreshold::getAnnotationAccuracyAuto) - .eq(YwThreshold::getId, id) - .eq(YwThreshold::getMonitorType, BusinessTypeEnum.VIDEO) - .one(); - VideoThresholdForm form = new VideoThresholdForm(); - BeanUtils.copyProperties(result, form); - return form; + @Transactional(rollbackFor = Exception.class) + public Result addBatch(WorkOrderWhite workOrderWhite) { + List<String> errorTypeListAdd = workOrderWhite.getErrorTypeList(); + List<WorkOrderWhite> whites = workOrderWhiteMapper.selectList(); + for (WorkOrderWhite white : whites) { + List<String> errorTypeList = new ArrayList<>(Arrays.asList(white.getErrorType().split(","))); + for (String newError : errorTypeListAdd) { + if (errorTypeList.contains(newError)) { + continue; + } else { + errorTypeList.add(newError); + } + } + white.setErrorType(String.join(",", errorTypeList)); + } + if (!CollectionUtils.isEmpty(whites)) { + workOrderWhiteMapper.deleteAll(); + workOrderWhiteMapper.insertBatch(whites); + } + return Result.ok(); + } + + private <T extends Comparable<T>> T parseThreshold(String thresholdStr, Class<?> type) { + if (Integer.class.equals(type)) { + return (T) Integer.valueOf(thresholdStr); + } else if (Float.class.equals(type)) { + return (T) Float.valueOf(thresholdStr); + } else if (Double.class.equals(type)) { + return (T) Double.valueOf(thresholdStr); + } else if (Long.class.equals(type)) { + return (T) Long.valueOf(thresholdStr); + } else { + throw new IllegalArgumentException("涓嶆敮鎸佽浆鎹㈢被鍨�" + type); + } + } + + public static boolean checkDuplic(List<WorkOrderWhiteExport> dataList) { + Set<String> serialNumbers = new HashSet<>(); + + for (WorkOrderWhiteExport white : dataList) { + String serialNumber = white.getSerialNumber(); + if (!serialNumbers.add(serialNumber)) { + return true; + } + } + return false; } } -- Gitblit v1.8.0