补充计时服务

alien-lawyer/src/main/java/shop/alien/lawyer/service/impl/LawyerClientConsultationOrderServiceImpl.java

@@ -88,6 +88,11 @@ public class LawyerClientConsultationOrderServiceImpl extends ServiceImpl<Lawyer
      */
     private static final String REFUND_STATUS_AGREED = "3";
 
+    /**
+     * 分钟转秒的转换系数
+     */
+    private static final long MINUTE_TO_SECOND = 60L;
+
     @Value("${order.coefficient}")
     private String coefficient;
     @Value("${order.coefficients}")
@@ -793,9 +798,202 @@ public class LawyerClientConsultationOrderServiceImpl extends ServiceImpl<Lawyer
         }
     }
 
+    /**
+     * 订单开始计时（律师端）
+     * <p>
+     * 订单开始计时功能说明：
+     * 1. 通过订单ID查询订单信息，验证订单是否存在
+     * 2. 校验订单状态，必须是进行中状态才能开始计时
+     * 3. 判断订单是否按分钟收费（chargeMinute和minuteNum都不为空）
+     * 4. 如果按分钟收费，计算超时时间并调用订单完成超时方法设置超时限制
+     * 5. 超时后系统会自动将订单状态更新为已完成
+     * </p>
+     *
+     * @param id 订单ID，不能为空
+     * @return R<Boolean> 操作结果，true表示成功，false表示失败
+     * @throws IllegalArgumentException 当订单ID为空或无效时抛出
+     * @author system
+     * @since 2025-01-XX
+     */
     @Override
     public R<Boolean> orderStartTiming(String id) {
-        return null;
+        log.info("订单开始计时请求开始，订单ID={}", id);
+
+        // 参数校验
+        validateOrderId(id);
+
+        try {
+            // 查询并校验订单
+            LawyerConsultationOrder order = queryAndValidateOrder(id);
+
+            // 校验订单状态
+            validateOrderStatus(order, id);
+
+            // 处理订单计时逻辑
+            return processOrderTiming(order, id);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("订单开始计时参数校验失败，订单ID={}，错误信息：{}", id, e.getMessage());
+            return R.fail(e.getMessage());
+        } catch (Exception e) {
+            log.error("订单开始计时异常，订单ID={}，异常信息：{}", id, e.getMessage(), e);
+            return R.fail("订单开始计时失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 校验订单ID
+     * <p>
+     * 检查订单ID是否为空或无效
+     * </p>
+     *
+     * @param id 订单ID
+     * @throws IllegalArgumentException 当订单ID为空或无效时抛出
+     */
+    private void validateOrderId(String id) {
+        if (StringUtils.isEmpty(id)) {
+            log.warn("订单开始计时参数校验失败：订单ID为空");
+            throw new IllegalArgumentException("订单ID不能为空");
+        }
+
+        // 去除前后空格后再次检查
+        String trimmedId = id.trim();
+        if (trimmedId.isEmpty()) {
+            log.warn("订单开始计时参数校验失败：订单ID为空字符串");
+            throw new IllegalArgumentException("订单ID不能为空");
+        }
+    }
+
+    /**
+     * 查询并校验订单
+     * <p>
+     * 根据订单ID查询订单信息，并校验订单是否存在
+     * </p>
+     *
+     * @param id 订单ID
+     * @return 订单对象
+     * @throws IllegalArgumentException 当订单不存在时抛出
+     */
+    private LawyerConsultationOrder queryAndValidateOrder(String id) {
+        LawyerConsultationOrder order = this.getById(id);
+        if (order == null) {
+            log.warn("订单开始计时失败：订单不存在，订单ID={}", id);
+            throw new IllegalArgumentException("订单不存在");
+        }
+
+        log.debug("订单查询成功，订单ID={}, 订单编号={}, 订单状态={}", 
+                id, order.getOrderNumber(), order.getOrderStatus());
+        return order;
+    }
+
+    /**
+     * 校验订单状态
+     * <p>
+     * 检查订单状态是否为进行中，只有进行中的订单才能开始计时
+     * </p>
+     *
+     * @param order 订单对象
+     * @param id    订单ID（用于日志记录）
+     * @throws IllegalArgumentException 当订单状态不是进行中时抛出
+     */
+    private void validateOrderStatus(LawyerConsultationOrder order, String id) {
+        Integer inProgressStatus = LawyerStatusEnum.INPROGRESS.getStatus();
+        Integer currentOrderStatus = order.getOrderStatus();
+
+        if (!inProgressStatus.equals(currentOrderStatus)) {
+            log.warn("订单开始计时失败：订单状态不是进行中，订单ID={}, 订单编号={}, 当前状态={}, 期望状态={}",
+                    id, order.getOrderNumber(), currentOrderStatus, inProgressStatus);
+            throw new IllegalArgumentException("订单状态不是进行中，无法开始计时");
+        }
+
+        log.debug("订单状态校验通过，订单ID={}, 订单编号={}, 订单状态=进行中", id, order.getOrderNumber());
+    }
+
+    /**
+     * 处理订单计时逻辑
+     * <p>
+     * 判断订单是否按分钟收费，如果是则设置超时限制
+     * </p>
+     *
+     * @param order 订单对象
+     * @param id    订单ID（用于日志记录）
+     * @return 操作结果
+     */
+    private R<Boolean> processOrderTiming(LawyerConsultationOrder order, String id) {
+        // 判断订单是否按分钟收费
+        if (isMinuteBasedCharging(order)) {
+            // 按分钟收费，设置超时限制
+            return setMinuteBasedTimeout(order, id);
+        } else {
+            // 不是按分钟收费，无需设置超时限制
+            log.info("订单不是按分钟收费，无需设置超时限制，订单ID={}, 订单编号={}", 
+                    id, order.getOrderNumber());
+            return R.data(true, "订单不是按分钟收费，无需设置超时限制");
+        }
+    }
+
+    /**
+     * 判断订单是否按分钟收费
+     * <p>
+     * 通过检查chargeMinute和minuteNum字段是否都不为空来判断
+     * </p>
+     *
+     * @param order 订单对象
+     * @return true表示按分钟收费，false表示不是按分钟收费
+     */
+    private boolean isMinuteBasedCharging(LawyerConsultationOrder order) {
+        return order.getChargeMinute() != null && order.getMinuteNum() != null;
+    }
+
+    /**
+     * 设置按分钟收费订单的超时限制
+     * <p>
+     * 计算超时时间（分钟数转换为秒），并调用订单完成超时方法设置超时限制
+     * </p>
+     *
+     * @param order 订单对象
+     * @param id    订单ID（用于日志记录）
+     * @return 操作结果
+     */
+    private R<Boolean> setMinuteBasedTimeout(LawyerConsultationOrder order, String id) {
+        try {
+            // 计算超时时间（分钟数转换为秒）
+            long timeoutSeconds = calculateTimeoutSeconds(order.getMinuteNum());
+
+            // 调用订单完成超时方法设置超时限制
+            orderExpirationService.setOrderCompleteTimeout(order.getOrderNumber(), timeoutSeconds);
+
+            log.info("订单开始计时成功，订单ID={}, 订单编号={}, 超时时间={}秒（{}分钟）",
+                    id, order.getOrderNumber(), timeoutSeconds, order.getMinuteNum());
+
+            return R.data(true, "订单开始计时成功");
+
+        } catch (Exception e) {
+            log.error("设置订单超时限制失败，订单ID={}, 订单编号={}，异常信息：{}",
+                    id, order.getOrderNumber(), e.getMessage(), e);
+            throw new RuntimeException("设置订单超时限制失败：" + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 计算超时时间（秒）
+     * <p>
+     * 将分钟数转换为秒数
+     * </p>
+     *
+     * @param minuteNum 分钟数，必须大于0
+     * @return 超时时间（秒）
+     * @throws IllegalArgumentException 当分钟数无效时抛出
+     */
+    private long calculateTimeoutSeconds(Integer minuteNum) {
+        if (minuteNum == null || minuteNum <= 0) {
+            log.warn("计算超时时间失败：分钟数无效，minuteNum={}", minuteNum);
+            throw new IllegalArgumentException("分钟数必须大于0");
+        }
+
+        long timeoutSeconds = minuteNum * MINUTE_TO_SECOND;
+        log.debug("计算超时时间，分钟数={}, 超时时间={}秒", minuteNum, timeoutSeconds);
+        return timeoutSeconds;
     }
 
     /**