新增管理员取钥匙类型

优化推送酒精异常数据逻辑

新增管理员取钥匙类型
优化推送酒精异常数据逻辑
2c
1 parent 509f3d2e
Showing 11 changed files with 208 additions and 25 deletions
Bsth-admin/src/main/java/com/ruoyi/common/SignStatusEnum.java
Bsth-admin/src/main/java/com/ruoyi/controller/dss/KeyBoxController.java
Bsth-admin/src/main/java/com/ruoyi/controller/dss/RemindDriverKeyLocalController.java
Bsth-admin/src/main/java/com/ruoyi/controller/dss2/DssDriverV2Controller.java
Bsth-admin/src/main/java/com/ruoyi/in/service/impl/SignInServiceV1Impl.java
Bsth-admin/src/main/java/com/ruoyi/service/ThreadJobService.java
Bsth-admin/src/main/java/com/ruoyi/service/impl/BigViewServiceImpl.java
Bsth-admin/src/main/java/com/ruoyi/service/impl/dss/FaceServiceImpl.java
Bsth-admin/src/main/resources/application-druid-dev.yml
Bsth-admin/src/main/resources/mapper/driver_scheduling/DriverSchedulingMapper.xml
Bsth-admin/src/main/resources/mybatis/mybatis-config.xml
@@ -11,7 +11,8 @@ public enum SignStatusEnum {
     SIGN_STATUS_ZONE_ENUM(0, "正常"),
     SIGN_STATUS_EMPTY_ENUM(1, "未签"),
     SIGN_STATUS_DELAY_ENUM(2, ""),
-    SIGN_STATUS_WINE_ENUM(3, "酒精测试超标");
+    SIGN_STATUS_WINE_ENUM(3, "酒精测试超标"),
+    SIGN_STATUS_FOUR_ENUM(4, "管理员代领");
  
  
     SignStatusEnum(Integer status, String description) {
@@ -260,30 +260,36 @@ public class KeyBoxController extends BaseController {
         return ResponseResult.success(vo);
     }
  
+    /**
+     * 人员领取钥匙的接口方法
+     *
+     * @param dto           经过验证的请求体，包含领取钥匙所需的信息
+     * @param bindingResult 用于存储校验结果的对象
+     * @return 返回包含领取钥匙结果的响应对象
+     */
     @PostMapping(value = "Driver/TakeKey")
     @ApiOperation(value = "20.人员领取钥匙")
     public ResponseResult<TakeKeyVo> takeKey(@Valid @RequestBody TakeKeyDTO dto, BindingResult bindingResult) {
+        // 检查是否有校验错误，如果有，则返回错误信息
         if (bindingResult.hasErrors()) {
             return ResponseResult.error(bindingResult.getFieldError().getDefaultMessage());
         }
  
+        // 验证设备信息，如果验证失败，则返回错误响应
         String msg = JwtAuthenticationTokenFilter.validateDevice(dto.getDevice());
         if (StringUtils.isNotEmpty(msg)) {
             log.info(msg);
             return ResponseResult.error(TipEnum.TIP_401.getCode(), TipEnum.TIP_401.getMsg());
         }
  
-
+        // 查询工作地点信息
         LinggangKeyWorkLocation entity = new LinggangKeyWorkLocation();
         entity.setDevice(dto.getDevice());
         List<LinggangKeyWorkLocation> schedulings = linggangKeyWorkLocationService.list(entity);
  
+        // 初始化钥匙信息列表
         List<KeyInfo> keyInfos = null;
-//        if (CollectionUtils.isNotEmpty(dto.getKeyItem())) {
-//            Set<String> codes = dto.getKeyItem().stream().map(TakeKeyKeyItemDTO::getKeyCode).filter(obj -> Objects.nonNull(obj)).collect(Collectors.toSet());
-//            keyInfos = keyInfoService.list(codes);
-//        }
-
+        // 根据车牌号码获取车辆信息，并关联钥匙信息
         Set<String> nbbms = dto.getKeyItem().stream().map(TakeKeyKeyItemDTO::getPlate).filter(obj -> StringUtils.isNotEmpty(obj)).collect(Collectors.toSet());
         if (CollectionUtils.isNotEmpty(nbbms)) {
             List<CarInfo> carInfos = carInfoService.list(nbbms);
@@ -303,29 +309,42 @@ public class KeyBoxController extends BaseController {
             }
         }
  
+        // 获取设备信息
         Equipment equipment = equipmentService.getOneByDeviceId(dto.getDevice());
         LinggangVenueInfo venueInfo = null;
         if (Objects.nonNull(equipment)) {
             venueInfo = venueInfoService.getById(equipment.getYardId());
         }
  
+        // 获取驾驶员信息
         NewDriver driver = newDriverService.getOne(dto.getStaffCode());
 //        if (Objects.isNull(driver)) {
 //            logger.info("[{}]没有找到driver", dto);
 //            return ResponseResult.error404();
 //        }
  
+        // 转换并处理领取钥匙的位置信息
         List<LinggangKeyWorkLocation> locations = convert(dto, schedulings, driver, keyInfos, 1, venueInfo);
+
+        //如果是管理员操作改变排班表的exType=3
+        if (dto.getOpeType()==16) {
+            LinggangScheduling scheduling = schedulingService.getById(locations.get(0).getSchedulingId());
+            scheduling.setExType(4);
+            schedulingService.updateById(scheduling);
+        }
+
         ResponseResult<Boolean> responseResult = linggangKeyWorkLocationService.saveAndDel(locations);
         if (Objects.isNull(responseResult)) {
             return ResponseResult.error();
         }
  
+        // 构建并返回响应结果
         TakeKeyVo vo = convertTakeKeyVo(dto, responseResult, equipment);
  
         return new ResponseResult<>(responseResult.getCode(), responseResult.getMsg(), vo);
     }
  
+
     @PostMapping(value = "Driver/TurnKey")
     @ApiOperation(value = "21.人员归还钥匙")
     public ResponseResult<TakeKeyVo> turnKey(@Valid @RequestBody TakeKeyDTO dto, BindingResult bindingResult) {
@@ -948,11 +967,26 @@ public class KeyBoxController extends BaseController {
         return vo;
     }
  
+    /**
+     * 将取钥匙请求数据转换为领岗钥匙工作位置信息列表
+     * 此方法主要用于处理取钥匙请求，将请求中的关键信息转换并封装到领岗钥匙工作位置对象中，
+     * 以便于后续的处理和存储
+     *
+     * @param dto 取钥匙请求数据传输对象，包含请求的相关信息
+     * @param schedulings 已调度的领岗钥匙工作位置信息列表，用于关联调度信息
+     * @param driver 司机信息对象，提供司机相关数据
+     * @param keyInfos 钥匙信息列表，用于匹配和获取钥匙详细信息
+     * @param ty 类型标识，用于区分不同的处理场景
+     * @param venueInfo 场地信息对象，提供场地相关数据
+     * @return 返回转换后的领岗钥匙工作位置信息列表
+     */
     private List<LinggangKeyWorkLocation> convert(TakeKeyDTO dto, List<LinggangKeyWorkLocation> schedulings, NewDriver driver, List<KeyInfo> keyInfos, int ty, LinggangVenueInfo venueInfo) {
+        // 检查请求中的钥匙项目是否为空，如果为空则直接返回空列表
         if (CollectionUtils.isEmpty(dto.getKeyItem())) {
             return Collections.emptyList();
         }
  
+        // 遍历请求中的每个钥匙项目，转换为领岗钥匙工作位置信息
         return dto.getKeyItem().stream().map(item -> {
             LinggangKeyWorkLocation location = new LinggangKeyWorkLocation();
             location.setDevice(item.getDevice());
@@ -965,6 +999,8 @@ public class KeyBoxController extends BaseController {
             location.setType1(ty);
             location.setCabinetNo(item.getParkCode());
             location.setJobCode(dto.getStaffCode());
+
+            // 如果已调度信息不为空，尝试匹配并关联调度信息
             if (CollectionUtils.isNotEmpty(schedulings)) {
                 Optional<LinggangKeyWorkLocation> opt = schedulings.stream().filter(s -> Objects.equals(item.getKey(), s.getCabinetNo())).findFirst();
                 if (opt.isPresent()) {
@@ -972,6 +1008,8 @@ public class KeyBoxController extends BaseController {
                     location.setSchedulingId(opt.get().getId());
                 }
             }
+
+            // 如果钥匙信息不为空，尝试匹配并关联钥匙信息
             if (Objects.nonNull(keyInfos)) {
                 Optional<KeyInfo> optional = keyInfos.stream().filter(k -> Objects.equals(k.getKeyCode(), item.getKeyCode())).findFirst();
                 if (optional.isPresent()) {
@@ -984,10 +1022,12 @@ public class KeyBoxController extends BaseController {
                 }
             }
  
+            // 如果司机信息不为空，关联司机信息
             if (Objects.nonNull(driver)) {
                 location.setCreateBy(Convert.toLong(driver.getId()));
             }
  
+            // 如果场地信息不为空，关联场地信息
             if (Objects.nonNull(venueInfo)) {
                 location.setYardId(venueInfo.getId());
                 location.setYardName(venueInfo.getName());
@@ -1140,4 +1180,16 @@ public class KeyBoxController extends BaseController {
             return target;
         }).orElseGet(null);
     }
+
+    /**
+     * 判断是否是管理员
+     *
+     * @param staffCode 员工编号
+     * @return 是否是管理员
+     */
+    private boolean isAdmin(String staffCode) {
+        // 这里可以根据实际情况实现管理员判断逻辑
+        // 例如：return adminList.contains(staffCode);
+        return "admin".equals(staffCode); // 示例逻辑
+    }
 }
@@ -59,50 +59,61 @@ public class RemindDriverKeyLocalController extends BaseController {
     @ApiOperation("司机提醒信息")
     @PostMapping(value = "/remind/driver/key/local/report")
     public ResponseResult<RemindDriverReportVo> remindDriverKeyLocalReport(@Valid @RequestBody RemindDriverReportDTO request, BindingResult bindingResult) {
+        // 检查参数绑定结果，如果有错误则返回错误信息
         if (bindingResult.hasErrors()) {
             return ResponseResult.error(bindingResult.getFieldError().getDefaultMessage());
         }
  
+        // 创建并初始化冷柜调度对象
         LinggangScheduling scheduling = new LinggangScheduling();
         scheduling.setJobCode(request.getJobCode());
         scheduling.setScheduleDate(request.getDate());
         scheduling.setStartScheduleDate(request.getDate());
         scheduling.setEndScheduleDate(DateUtils.addDays(request.getDate(), 1));
  
-
+        // 创建并初始化订单实体对象，用于排序
         OrderEntity orderEntity = new OrderEntity();
         orderEntity.setOrder("ascending");
         orderEntity.setProp("fcsjT");
  
+        // 查询符合条件的冷柜调度列表
         List<LinggangScheduling> linggangSchedulings = linggangSchedulingService.list(scheduling, orderEntity);
         int size = CollectionUtils.size(linggangSchedulings);
  
+        // 初始化钥匙信息和车辆信息列表
         List<KeyInfo> keyInfos = null;
         List<CarInfo> carInfos = null;
+
+        // 如果调度列表不为空，根据调度信息获取车辆信息
         if (0 < size) {
             Set<String> nbbms = linggangSchedulings.stream().map(LinggangScheduling::getNbbm).collect(Collectors.toSet());
             carInfos = carInfoService.list(nbbms);
         }
  
+        // 如果车辆信息不为空，根据车辆信息获取钥匙信息
         if (CollectionUtils.isNotEmpty(carInfos)) {
             Set<String> plateNums = carInfos.stream().map(CarInfo::getPlateNum).collect(Collectors.toSet());
             keyInfos = keyInfoService.listPlateNums(plateNums);
         }
  
+        // 计算车辆和钥匙信息的大小
         int carSize = CollectionUtils.size(carInfos);
         int keyInfoSize = CollectionUtils.size(keyInfos);
  
+        // 创建并初始化提醒司机报告视图对象
         RemindDriverReportVo reportVo = new RemindDriverReportVo();
         List<LinggangScheduling> values = linggangSchedulings.stream().filter(ls -> StringUtils.equalsAnyIgnoreCase(ls.getBcType(), "out")).collect(Collectors.toList());
         size = CollectionUtils.size(values);
         reportVo.setCount(Convert.toLong(size));
  
+        // 如果调度列表不为空，处理每个调度信息，生成提醒信息列表
         if (size > 0) {
             List<RemindKeyInfoLocalVo> remindKeyInfoLocalVoList = new ArrayList<>();
             for (int i = 0; i < size; i++) {
                 RemindKeyInfoLocalVo localVo = new RemindKeyInfoLocalVo();
                 localVo.setNbbm(values.get(i).getNbbm());
  
+                // 初始化工作位置对象
                 LinggangKeyWorkLocation workLocation = new LinggangKeyWorkLocation();
                 if (carSize > 0 && keyInfoSize > 0) {
                     int index = i;
@@ -112,11 +123,15 @@ public class RemindDriverKeyLocalController extends BaseController {
                         optional.ifPresent(k -> workLocation.setKeyInfoId(k.getId()));
                     }
                 }
+
+                // 根据钥匙ID和时间获取工作位置信息
                 List<LinggangKeyWorkLocation> keyWorkLocations = null;
                 if (Objects.nonNull(workLocation.getKeyInfoId())) {
                     workLocation.setMaxCreateDate(new Date());
                     keyWorkLocations = linggangKeyWorkLocationService.getTenByKeyIdAndTime(workLocation);
                 }
+
+                // 处理工作位置信息，确定钥匙状态和相关设备信息
                 if (CollectionUtils.isNotEmpty(keyWorkLocations)) {
                     int klSize = CollectionUtils.size(keyWorkLocations);
                     LinggangKeyWorkLocation sourceKL200 = null;
@@ -137,6 +152,7 @@ public class RemindDriverKeyLocalController extends BaseController {
                         }
                     }
  
+                    // 根据工作位置信息设置提醒信息
                     if (Objects.nonNull(sourceKL0) && Objects.nonNull(sourceKL1) && Objects.nonNull(sourceKL0.getIndex()) && Objects.nonNull(sourceKL1.getIndex())) {
                         if (sourceKL0.getIndex() > sourceKL1.getIndex()) {
                             localVo.setKeyInfoStatus(0);
@@ -168,24 +184,43 @@ public class RemindDriverKeyLocalController extends BaseController {
                     remindKeyInfoLocalVoList.add(localVo);
                 }
             }
+
+            // 设置报告视图对象的提醒信息列表和当前位置信息
             if(CollectionUtils.isNotEmpty(remindKeyInfoLocalVoList)) {
                 reportVo.setRemindKeyInfoLocalVoList(remindKeyInfoLocalVoList);
                 reportVo.setCurrentKeyLocaltion(remindKeyInfoLocalVoList.get(0).getEquipmentName());
             }
         }
  
+        // 返回成功响应结果
         return ResponseResult.success(reportVo);
     }
  
+    /**
+     * 设置返回信息
+     * 此方法用于将设备信息和场地名称设置到本地提醒信息对象中
+     *
+     * @param sourceKL200      来自KL200的源数据对象，包含设备ID和场地名称等信息
+     * @param localVo          本地提醒信息对象，用于存储返回的设备名称和场地名称
+     */
     private void setReturnInfo(LinggangKeyWorkLocation sourceKL200, RemindKeyInfoLocalVo localVo) {
+        // 检查输入对象是否为空，如果任一对象为空，则不执行后续操作
         if (Objects.isNull(sourceKL200) || Objects.isNull(localVo)) {
             return;
         }
+
+        // 根据设备ID获取设备信息
         Equipment equipment = equipmentService.getOneByDeviceId(sourceKL200.getDevice());
+
+        // 检查是否找到对应的设备信息，如果未找到，则不执行后续操作
         if (Objects.isNull(equipment)) {
             return;
         }
+
+        // 设置本地提醒信息对象的返回设备名称
         localVo.setReturnEquipmentName(equipment.getName());
+
+        // 设置本地提醒信息对象的返回场地名称
         localVo.setReturnYardName(sourceKL200.getYardName());
     }
 }
@@ -54,23 +54,35 @@ public class DssDriverV2Controller {
     @Autowired
     private NewDriverService newDriverService;
  
+    /**
+     * 线下签到接口
+     *
+     * @param signV2DTO 签到请求数据传输对象
+     * @param bindingResult 数据校验结果
+     * @return 返回签到结果封装对象
+     */
     @ApiOperation("线下签到")
     @PostMapping("/offline/sign/in/add")
     public ResponseResult<DssSignVo> addSign(@RequestBody DssSignV2DTO signV2DTO, BindingResult bindingResult) {
+        // 数据校验，如果有错误则返回错误信息
         if (bindingResult.hasErrors()) {
             return ResponseResult.error(bindingResult.getFieldError().getDefaultMessage());
         }
  
+        // 获取审核人员信息，如果找不到则返回错误信息
         NewDriver driver = newDriverService.getOne(signV2DTO.getAuditJobCode());
         if (Objects.isNull(driver)) {
             return ResponseResult.error("无法查找到审核人员");
         }
  
-
+        // 将请求DTO转换为签到实体对象，并设置创建者信息
         SignIn signIn = convertSignIn(signV2DTO);
         signIn.setCreateBy(Convert.toStr(driver.getId()));
+
+        // 调用服务添加签到信息，并处理结果
         AjaxResult ajaxResult = signInServiceV1.addSignInOffice(signIn);
  
+        // 如果添加成功，则进行后续处理，包括获取字典数据、复制属性等
         if (Objects.nonNull(ajaxResult) && ajaxResult.isSuccess()) {
             SysDictData sysDictData = new SysDictData();
             sysDictData.setDictType("drinking");
@@ -86,12 +98,14 @@ public class DssDriverV2Controller {
  
                 vo.setName(signInV1.getDriver().getPersonnelName());
                 vo.setPosts(signInV1.getPosts());
+                // 将处理后的数据转换为响应结果并返回
                 ResponseResult<DssSignVo> responseResult = ResponseResult.success(convertSignInVo(vo, signV2DTO, dictData, signInV1));
                 responseResult.setMsg(Convert.toStr(ajaxResult.get(AjaxResult.MSG_TAG)));
                 return responseResult;
             }
         }
  
+        // 如果添加失败，则根据AjaxResult中的信息返回相应的错误结果
         return ResponseResult.error(Convert.toInt(ajaxResult.get(AjaxResult.CODE_TAG)), Convert.toStr(ajaxResult.get(AjaxResult.MSG_TAG)));
     }
  
@@ -141,6 +155,7 @@ public class DssDriverV2Controller {
             signIn.setImage(dto.getImageContent());
             signIn.setResourceType(2);
         }
+        signIn.setExceptionId(dto.getExceptionId());
  
 //        SysDictData sysDictData = querySystData(null,"drunkenness");
 //        if(Objects.nonNull(sysDictData)){
@@ -151,20 +166,34 @@ public class DssDriverV2Controller {
     }
  
  
+    /**
+     * 将登录响应信息、签到信息、字典数据和签到记录转换为DSS签到视图对象
+     *
+     * @param responseVo 登录响应视图对象，包含登录相关信息
+     * @param dto 签到信息DTO，包含签到相关数据
+     * @param dictData 字典数据，用于参考测试值的阈值
+     * @param signInV1 签到记录，包含用户的签到详情
+     * @return 返回一个转换后的DSS签到视图对象
+     */
     private DssSignVo convertSignInVo(SignInResponseVo responseVo, DssSignV2DTO dto, SysDictData dictData, SignInV1 signInV1) {
+        // 初始化DSS签到视图对象
         DssSignVo vo = new DssSignVo();
+        // 设置测试ID，即登录响应中的ID
         vo.setTestId(Convert.toStr(responseVo.getId()));
  
-
+        // 根据签到状态判断测试结果，如果是签到状态区内，则测试结果为2，否则为0
         Integer testResult = bigViewServiceV1.isSignStatusZoneEnum(signInV1.getSignIn()) ? 2 : 0;
         vo.setTestResult(testResult);
+        // 如果字典数据为空或测试结果为0且测试值大于字典数据的阈值，则设置测试结果为1
         if (Objects.isNull(dictData) || Objects.equals(testResult, 0) && dto.getTestValue() > Convert.toLong(dictData.getDictValue())) {
             vo.setTestResult(1);
         }
  
+        // 根据签到状态设置结果，如果签到状态为1，则结果为0，否则为1
         Integer result = Objects.equals(1, signInV1.getSignIn().getStatus()) ? 0 : 1;
         vo.setResult(result);
  
+        // 返回转换后的DSS签到视图对象
         return vo;
     }
  
@@ -93,6 +93,7 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
     @Autowired
     private ISignInService signInService;
  
+    @Autowired
     private EquipmentExceptionReportService equipmentExceptionReportService;
  
     private static final FastDateFormat HHMM = FastDateFormat.getInstance("HH:mm");
@@ -180,53 +181,71 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
         return saveData(signIn, scheduling, calDriverScheduling, driver, signInV1);
     }
  
+    /**
+     * 添加员工签到信息
+     *
+     * @param signIn 员工签到对象，包含签到的相关信息
+     * @return 返回AjaxResult对象，包含签到操作的结果
+     */
     @Override
     public AjaxResult addSignInOffice(SignIn signIn) {
+        // 创建SignInV1对象，并设置签到信息
         SignInV1 signInV1 = new SignInV1();
         signInV1.setSignIn(signIn);
  
         // 查询员工信息
         Driver driver = driverMapper.getDriverInfoByJobCode(signIn.getJobCode());
+        // 如果员工不存在，记录日志并返回警告信息
         if (Objects.isNull(driver)) {
             log.info("这个工号的员工不存在:[{}]", signIn);
             return AjaxResult.warn("这个工号的员工不存在！");
         }
+        // 设置员工信息
         signInV1.setDriver(driver);
  
+        // 如果签到时间未设置，则设置为当前时间
         if (Objects.isNull(signIn.getCreateTime())) {
             signIn.setCreateTime(DateUtils.getNowDate());
         }
  
+        // 获取签到时间的日期部分
         long dateTime = signIn.getCreateTime().getTime();
         Date date = DateUtils.shortDate(new Date(dateTime));
         DriverScheduling scheduling = null;
         CalDriverScheduling calDriverScheduling = null;
  
+        // 查询员工的排班信息
         List<DriverSchedulingV1> schedulings = schedulingServiceV1.queryByJobCodeAndSchedulingDate(signIn.getJobCode(), date);
+        // 如果没有排班信息，保存签到信息并返回成功
         if (CollectionUtils.isEmpty(schedulings)) {
             saveSignOfNoScheduling(signIn, ErrorTypeProperties.WORK_DAY_ERROR);
             switchAndChooseAlcohol(signIn, driver, null);
             return saveData(signIn, null, null, driver, signInV1);
         } else if (Objects.equals(2, signIn.getType())) {
+            // 根据签到类型查找对应的排班信息
             calDriverScheduling = findSchedulingByDateTime(schedulings, dateTime, ConstDriverProperties.BC_TYPE_IN);
         } else {
             calDriverScheduling = findSchedulingByDateTime(schedulings, dateTime, ConstDriverProperties.BC_TYPE_OUT);
         }
  
+        // 如果没有找到合适的排班信息，记录日志，保存签到信息并返回成功
         if (Objects.isNull(calDriverScheduling.getDriverScheduling())) {
             log.info("当天没有满足要求的数据:dateTime:[{}],signIn:[{}],scheduling:[{}]", dateTime, signIn, JSON.toJSONString(scheduling));
             saveSignOfNoScheduling(signIn, ErrorTypeProperties.WORK_DAY_ERROR);
             return AjaxResult.success(ErrorTypeProperties.WORK_DAY_ERROR);
         }
  
+        // 设置排班信息
         scheduling = calDriverScheduling.getDriverScheduling();
         signInV1.setDriverScheduling(calDriverScheduling.getDriverScheduling());
  
+        // 如果排班信息中没有签到ID，执行签到逻辑
         if (Objects.isNull(scheduling.getSignInId())) {
             switchAndChooseTime(signIn, scheduling, dateTime);
             switchAndChooseAlcohol(signIn, driver, scheduling);
  
         } else {
+            // 如果排班信息中已有签到ID，更新签到逻辑
             log.info("签到的数据为：[{}]", scheduling);
             SignInV1 sourceSign = getById(scheduling.getSignInId());
             if (Objects.nonNull(sourceSign)) {
@@ -235,9 +254,10 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
             }
         }
  
+        // 更新签到信息
         signInV1.setSignIn(signIn);
  
-
+        // 保存签到数据并返回结果
         return saveData(signIn, scheduling, calDriverScheduling, driver, signInV1);
     }
  
@@ -262,26 +282,39 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
         return wrapper.update();
     }
  
+    /**
+     * 保存签到数据
+     *
+     * @param signIn 签到信息对象
+     * @param scheduling 司机排班信息对象
+     * @param calDriverScheduling 计划司机排班信息对象
+     * @param driver 司机信息对象
+     * @param signInV1 签到信息V1对象
+     * @return 返回Ajax结果对象
+     */
     private AjaxResult saveData(SignIn signIn, DriverScheduling scheduling, CalDriverScheduling calDriverScheduling, Driver driver, SignInV1 signInV1) {
+        // 提取视频内容，并将图片内容设置为null以进行后续处理
         String videoContent = signIn.getImage();
         signIn.setImage(null);
  
+        // 处理扩展类型字段
         signIn.setExType1(signIn.getExType());
         Integer type = Objects.isNull(signIn.getExType()) ? 0 : bigViewServiceV1.isSignStatusWineEnum(signIn) ? 3 : signIn.getExType() > 0 ? 1 : 0;
         signIn.setExType(type);
  
+        // 插入签到数据到数据库
         signInMapper.insertSignIn(signIn);
  
+        // 如果签到图片内容非空，进行处理
         if (org.apache.commons.lang3.StringUtils.isNotEmpty(signIn.getImage())) {
-
             signIn.setImage(null);
         }
+        // 处理视频内容并上传
         if (org.apache.commons.lang3.StringUtils.isNotEmpty(videoContent) && Objects.equals(signIn.getResourceType(), 2)) {
             StringBuilder builder = new StringBuilder();
             builder.append("sign/video/offline/");
             builder.append(DateUtil.shortNowStr());
             builder.append("/");
-            builder.append("/");
             builder.append(signIn.getId());
             builder.append("/");
             builder.append(java.util.UUID.randomUUID().toString().replace("-", ""));
@@ -299,6 +332,7 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
             signInResource.setCreateBy(Convert.toLong(signIn.getCreateBy()));
             signInResourceService.save(signInResource);
         } else if (org.apache.commons.lang3.StringUtils.isNotEmpty(videoContent)) {
+            // 处理图片内容并上传
             StringBuilder builder = new StringBuilder();
             builder.append("sign/images/offline/");
             builder.append(DateUtil.shortNowStr());
@@ -308,7 +342,7 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
             builder.append(java.util.UUID.randomUUID().toString().replace("-", ""));
             builder.append(".jpg");
  
-            uploadUtil.uploadImageOfBase64(videoContent, builder.toString(),"jpg");
+//            uploadUtil.uploadImageOfBase64(videoContent, builder.toString(),"jpg");
  
             LinggangSignInResource signInResource = new LinggangSignInResource();
             signInResource.setSignId(signIn.getId());
@@ -320,16 +354,19 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
             signInResource.setCreateBy(Convert.toLong(signIn.getCreateBy()));
             signInResourceService.save(signInResource);
         }
+        // 更新签到V1对象ID
         signInV1.setId(signIn.getId());
         // 更新考勤
         if (Objects.nonNull(calDriverScheduling)) {
             schedulingService.computedSignInBySignIn(scheduling, calDriverScheduling.getIndex(), signIn, true, signInService);
         }
  
+        // 更新临时缓存中的签到状态
         if (TempCache.checkJobCodeExist(signIn.getJobCode())) {
             TempCache.updateSignStatus(signIn.getJobCode());
         }
  
+        // 更新签到记录中的排班ID
         if (Objects.nonNull(scheduling)) {
             LambdaUpdateWrapper<SignInV1> updateWrapper = new LambdaUpdateWrapper<>();
  
@@ -340,6 +377,7 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
         // 异常保存到异常异常中
         threadJobService.asyncInsertExceptionRecord(signIn, driver, scheduling);
  
+        // 更新设备异常报告状态
         if (Objects.nonNull(signIn.getExceptionId())) {
             LambdaUpdateWrapper<EquipmentExceptionReport> reportLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
             reportLambdaUpdateWrapper.set(EquipmentExceptionReport::getStatus, 3).set(EquipmentExceptionReport::getUpdateTime, new Date())
@@ -347,6 +385,7 @@ public class SignInServiceV1Impl extends ServiceImpl&lt;SignInMapperV1, SignInV1&gt; i
             equipmentExceptionReportService.update(reportLambdaUpdateWrapper);
         }
  
+        // 处理Ajax结果并返回
         return handleAjaxResult(signIn, signInV1);
     }
  
@@ -201,7 +201,8 @@ public class ThreadJobService {
  
     @Async
     public void asyncInsertExceptionRecord(SignIn signIn, Driver driver, DriverScheduling scheduling) {
-        if (!SIGN_NO_EX_NUM.equals(signIn.getExType())) {
+        // 异常处理，如果签到异常，则插入异常记录
+        if (!SIGN_NO_EX_NUM.equals(signIn.getExType()) && Objects.isNull(signIn.getExceptionId())) {
             EquipmentException exception = new EquipmentException();
             exception.setExType(signIn.getExType());
             exception.setDeviceId(signIn.getDeviceId());
@@ -374,6 +375,7 @@ public class ThreadJobService {
                     map.put("noticeIssuer", "运控中心");
                     map.put("noticeRecipient", "05-" + newDriver.getJobCode());
                     map.put("noticeTitle", "异常通知");
+                    map.put("noticeTime", ConstDateUtil.formatDate("yyyy-MM-dd HH:mm:ss", signIn.getCreateTime()));
 //                    map.put("noticeSubtitle", "");
  
                     StringBuilder builder = new StringBuilder();
@@ -410,6 +412,7 @@ public class ThreadJobService {
         map.put("noticeIssuer", "运控中心");
         map.put("noticeRecipient", "05-006154");
         map.put("noticeTitle", "异常通知");
+        map.put("noticeTime", "2025-02-26 10:01:52");
         map.put("noticeContent", "工号：1700003,姓名：测试,工种：驾驶员,排班：有排班,打卡时间：2025-01-07 03:29:20,酒精测试超标，当前测试值达到50mg/100ml。属于饮酒后驾驶机动车");
         map.put("phone", "13681905733");
         map.put("smsContent", "工号：1700003,姓名：测试,工种：驾驶员,排班：有排班,打卡时间：2025-01-07 03:29:20,酒精测试超标，当前测试值达到50mg/100ml。属于饮酒后驾驶机动车");
@@ -419,7 +422,7 @@ public class ThreadJobService {
         map.put("signature", key);
         String result = null;
         try {
-            result = HttpUtil.get("http://10.10.200.142:9103/commonOpenDataApi/sendAppAndSmsNotice", (Map<String, Object>) JSON.toJSON((map)), 10000);
+            result = HttpUtil.get("http://192.168.168.27:9103/commonOpenDataApi/sendAppAndSmsNotice", (Map<String, Object>) JSON.toJSON((map)), 10000);
             System.out.println(result);
         } catch (Exception e) {
             e.printStackTrace();
@@ -406,26 +406,35 @@ public class BigViewServiceImpl implements BigViewService {
     /**
      * 自编号为key 存储人员信息
      *
-     * @param map
-     * @return
+     * @param map 原始映射，键为字符串，值为DriverScheduling对象列表
+     * @return 返回一个新的映射，键为字符串，值为LineInfo对象
      */
     private Map<String, LineInfo> transformMapByMacheList(Map<String, List<DriverScheduling>> map) {
+        // 初始化一个新的映射，用于存储转换后的人员信息
         Map<String, LineInfo> matchMap = new HashMap<>();
+        // 检查输入映射是否为空，如果为空则直接返回新的空映射
         if (CollectionUtil.isEmpty(map)){
             return matchMap;
         }
+        // 遍历输入映射的每个条目
         for (Map.Entry<String, List<DriverScheduling>> entry : map.entrySet()) {
+            // 获取当前条目的值，即DriverScheduling对象列表
             List<DriverScheduling> value = entry.getValue();
+            // 过滤出符合特定条件（出库类型为OUT且自编号不为空）的DriverScheduling对象，并按发车时间排序
             List<DriverScheduling> list = value.stream().filter(item -> BC_TYPE_OUT.equals(item.getBcType()) && !Objects.isNull(item.getNbbm())).sorted(Comparator.comparing(DriverScheduling::getFcsjT)).collect(Collectors.toList());
+            // 遍历过滤并排序后的DriverScheduling对象列表
             for (DriverScheduling scheduling : list) {
                 // 把每辆车的人员信息收集起来
                 String nbbm = scheduling.getNbbm();
+                // 尝试从新映射中获取当前自编号对应的LineInfo对象
                 LineInfo lineInfoList = matchMap.get(nbbm);
+                // 如果新映射中不存在当前自编号对应的LineInfo对象，则创建新的LineInfo对象并添加到新映射中
                 if (Objects.isNull(lineInfoList)) {
                     LineInfo lineInfo = new LineInfo();
                     lineInfo.setNbbm(nbbm);
                     lineInfo.setLineName(scheduling.getLineName());
                     lineInfo.setFleetName(scheduling.getFleetName());
+                    // 根据调度信息获取人员信息并设置到LineInfo对象中
                     LineInfo.PersonInfoVo personInfoVo = getPersonInfoVo(scheduling);
                     if (DRIVER_STRING.equals(scheduling.getPosts())) {
                         lineInfo.setDriverInfoVo(personInfoVo);
@@ -434,11 +443,13 @@ public class BigViewServiceImpl implements BigViewService {
                     }
                     matchMap.put(nbbm, lineInfo);
                 } else {
+                    // 如果新映射中已存在当前自编号对应的LineInfo对象，则更新其人员信息
                     LineInfo.PersonInfoVo personInfoVo = getPersonInfoVo(scheduling);
                     handleMoreStatus(matchMap, scheduling, nbbm, personInfoVo, scheduling);
                 }
             }
         }
+        // 返回转换后的新映射
         return matchMap;
     }
  
@@ -482,8 +493,17 @@ public class BigViewServiceImpl implements BigViewService {
         }
     }
  
+    /**
+     * 根据司机排班信息获取个人信息服务对象
+     * 此方法用于将司机排班信息转换为个人信息服务对象，以便在 lineage 模块中使用
+     * 它根据排班信息中的例外类型和备注来确定签到状态，并设置工作编号和姓名
+     *
+     * @param scheduling 司机排班信息，包含例外类型、备注、工作编号和姓名
+     * @return 返回一个填充了签到状态、工作编号和姓名的个人信息服务对象
+     */
     private LineInfo.PersonInfoVo getPersonInfoVo(DriverScheduling scheduling) {
         LineInfo.PersonInfoVo personInfoVo = new LineInfo.PersonInfoVo();
+        // 根据排班信息中的例外类型设置签到状态
         if (Objects.isNull(scheduling.getExType())) {
             personInfoVo.setSignStatus(SIGN_STATUS_EMPTY_ENUM);
         } else {
@@ -502,8 +522,11 @@ public class BigViewServiceImpl implements BigViewService {
                 case 3:
                     personInfoVo.setSignStatus(SIGN_STATUS_WINE_ENUM);
                     break;
+                case 4:
+                    personInfoVo.setSignStatus(SIGN_STATUS_FOUR_ENUM);
             }
         }
+        // 设置工作编号和姓名
         personInfoVo.setJobCode(scheduling.getJobCode());
         personInfoVo.setName(scheduling.getName());
         return personInfoVo;
@@ -203,10 +203,10 @@ public class FaceServiceImpl implements FaceService {
         StringBuilder builder = new StringBuilder();
         builder.append(RuoYiConfig.getDownloadPath1());
         if (!StringUtils.startsWith(dr.getImage(), "/")) {
-           dr.setImage("/"+dr.getImage()) ;
+            dr.setImage("/" + dr.getImage());
         }
-        if(!StringUtils.startsWith(dr.getImage(),"/head")){
-            dr.setImage("/head"+dr.getImage()) ;
+        if (!StringUtils.startsWith(dr.getImage(), "/head")) {
+            dr.setImage("/head" + dr.getImage());
         }
         builder.append(dr.getImage());
  
@@ -138,7 +138,7 @@ ruoyi:
     # 实例演示开关
     demoEnabled: true
     # 文件路径 示例（ Windows配置D:/ruoyi/uploadPath，Linux配置 /home/ruoyi/uploadPath）
-    profile: D:/temp/temp/bsth
+    profile: D:/work/project/Documents/sign/lingang/uploadPath
     # 获取ip地址开关
     addressEnabled: false
     # 验证码类型 math 数字计算 char 字符验证
@@ -190,7 +190,7 @@ api:
         people:
             url: https://api.dingtalk.com/v1.0/yida/forms/instances/search
 log:
-    path: D:/ruoyi/logs
+    path: D:/work/project/Documents/sign/lingang/logs
 server:
     port: 8100
 netty:
@@ -225,7 +225,7 @@ bsth:
         sdk:
             key: C21s5J1n1rHwXPkvVjubKshtofV5sHXvyUQqSWYxHp2b
         lib:
-            path: D:/work/code/jienengjiancha/bsth-alcohol-sign/Bsth-admin/src/main/resources/libs/WIN64
+            path: D:/work/project/java/bsth-alcohol-sign/Bsth-admin/src/main/resources/libs/WIN64
         faceFeature:
             url: http://222.76.217.238:8880/fcgi-bin/entry.fcgi/system
     process:
@@ -74,7 +74,7 @@
                 and scheduling.job_code = #{jobCode}
             </if>
             <if test="name !=null and name != ''">
-                and `name` = #{name}
+                and scheduling.`name` = #{name}
             </if>
             <if test="lineName !=null and lineName != ''">
                 and scheduling.line_name like concat('%', #{lineName}, '%')
@@ -15,6 +15,7 @@ PUBLIC &quot;-//mybatis.org//DTD Config 3.0//EN&quot;
         <setting name="logImpl"                  value="SLF4J"  />
         <!-- 使用驼峰命名法转换字段 -->
 		<!-- <setting name="mapUnderscoreToCamelCase" value="true"/> -->
+<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
 	</settings>
  
 </configuration>