调整订单相关代码

nightFragrance-admin/src/main/java/com/ylx/web/controller/massage/CancelOrderApplicationController.java

@@ -111,64 +111,65 @@ public class CancelOrderApplicationController extends BaseController {
     @ApiOperation("根据主键ID查询订单详情")
     @GetMapping(value = "/getByOrderId")
     public R<CancelOrderApplicationDetailVo> getByOrderId(@RequestParam("id") String id) {
-        try {
-            if (StringUtils.isBlank(id)) {
-                return R.fail("ID不能为空");
-            }
-            //通过主键ID查询退单申请信息
-            CancelOrderApplication application = cancelOrderApplicationService.getById(id);
-            if (application == null) {
-                return R.fail("退单申请不存在");
-            }
-            String orderId = application.getOrderId();
-            TOrder order = orderService.getById(orderId);
-            if (order == null) {
-                return R.fail("订单不存在");
-            }
-            CancelOrderApplicationDetailVo vo = new CancelOrderApplicationDetailVo();
-            BeanUtils.copyProperties(order, vo);
-            vo.setId(id);
-            Integer status = vo.getnStatus();
-            vo.setStatusName(OrderStatusEnum.getDescByCode(status));
-
-            //获取技师ID
-            String techId = order.getcJsId();
-            //根据技师ID查询技师信息
-            TJs tech = jsService.getById(techId);
-            vo.setJsName(tech.getcName());
-            vo.setCNickName(tech.getcNickName());
-            vo.setJsPhone(tech.getcPhone());
-
-            // 设置服务时长（分钟）
-            vo.setServiceDuration(application.getServiceDuration());
-            JSONArray objects = order.getcGoods();
-            // 遍历商品列表，累加项目金额
-            BigDecimal projectPrice = BigDecimal.ZERO;
-            StringBuffer projectNameBuffer = new StringBuffer();
-            //项目时长
-            BigDecimal projectDuration = new BigDecimal(0);
-            for (int i = 0; i < objects.size(); i++) {
-                JSONObject object = objects.getJSONObject(i);
-                BigDecimal price = object.getBigDecimal("dPrice");
-                projectPrice = projectPrice.add(price);
-                projectNameBuffer.append(object.getString("cTitle")).append(" ");
-                projectDuration = projectDuration.add(object.getBigDecimal("nMinute"));
-            }
-            // 设置退单原因
-            vo.setCancelOrderReason(application.getCancelOrderReason());
-            // 设置项目名称
-            vo.setProjectName(projectNameBuffer.toString().trim());
-            // 设置项目时长
-            vo.setProjectDuration(projectDuration.intValue());
-            // 设置项目金额
-            vo.setProjectPrice(projectPrice);
-            // 设置退款金额
-            vo.setRefundAmount(application.getRefundAmount());
-            return R.ok(vo);
-        } catch (Exception e) {
-            e.printStackTrace();
-            throw new RuntimeException(e);
-        }
+//        try {
+//            if (StringUtils.isBlank(id)) {
+//                return R.fail("ID不能为空");
+//            }
+//            //通过主键ID查询退单申请信息
+//            CancelOrderApplication application = cancelOrderApplicationService.getById(id);
+//            if (application == null) {
+//                return R.fail("退单申请不存在");
+//            }
+//            String orderId = application.getOrderId();
+//            TOrder order = orderService.getById(orderId);
+//            if (order == null) {
+//                return R.fail("订单不存在");
+//            }
+//            CancelOrderApplicationDetailVo vo = new CancelOrderApplicationDetailVo();
+//            BeanUtils.copyProperties(order, vo);
+//            vo.setId(id);
+//            Integer status = vo.getnStatus();
+//            vo.setStatusName(OrderStatusEnum.getDescByCode(status));
+//
+//            //获取技师ID
+//            String techId = order.getcJsId();
+//            //根据技师ID查询技师信息
+//            TJs tech = jsService.getById(techId);
+//            vo.setJsName(tech.getcName());
+//            vo.setCNickName(tech.getcNickName());
+//            vo.setJsPhone(tech.getcPhone());
+//
+//            // 设置服务时长（分钟）
+//            vo.setServiceDuration(application.getServiceDuration());
+//            JSONArray objects = order.getcGoods();
+//            // 遍历商品列表，累加项目金额
+//            BigDecimal projectPrice = BigDecimal.ZERO;
+//            StringBuffer projectNameBuffer = new StringBuffer();
+//            //项目时长
+//            BigDecimal projectDuration = new BigDecimal(0);
+//            for (int i = 0; i < objects.size(); i++) {
+//                JSONObject object = objects.getJSONObject(i);
+//                BigDecimal price = object.getBigDecimal("dPrice");
+//                projectPrice = projectPrice.add(price);
+//                projectNameBuffer.append(object.getString("cTitle")).append(" ");
+//                projectDuration = projectDuration.add(object.getBigDecimal("nMinute"));
+//            }
+//            // 设置退单原因
+//            vo.setCancelOrderReason(application.getCancelOrderReason());
+//            // 设置项目名称
+//            vo.setProjectName(projectNameBuffer.toString().trim());
+//            // 设置项目时长
+//            vo.setProjectDuration(projectDuration.intValue());
+//            // 设置项目金额
+//            vo.setProjectPrice(projectPrice);
+//            // 设置退款金额
+//            vo.setRefundAmount(application.getRefundAmount());
+//            return R.ok(vo);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            throw new RuntimeException(e);
+//        }
+        return null;
     }
 
     /**
@@ -180,48 +181,49 @@ public class CancelOrderApplicationController extends BaseController {
     @ApiOperation("审核退单申请")
     @PostMapping("/audit")
     public R audit(@RequestBody CancelOrderApplication cancelOrderApplication) {
-        try {
-            if (StringUtils.isBlank(cancelOrderApplication.getId())) {
-                return R.fail("退单申请ID不能为空");
-            }
-            // 检查申请是否存在
-            CancelOrderApplication application = cancelOrderApplicationService.getById(cancelOrderApplication.getId());
-            if (application == null) {
-                return R.fail("退单申请不存在");
-            }
-            //检查当前审核状态是否为待审核
-            if (application.getAuditStatus() != 0) {
-                return R.fail("退单申请当前状态不是待审核");
-            }
-
-            // 审核退单申请
-            application.setRefundAmount(cancelOrderApplication.getRefundAmount());
-            application.setAuditRemark(cancelOrderApplication.getAuditRemark());
-            application.setOrderStatus(8);
-            application.setAuditStatus(cancelOrderApplication.getAuditStatus());
-            // 审核通过，更新订单状态为退单审核通过
-            if (application.getAuditStatus() == 1) {
-                // 更新订单状态
-                TOrder order = new TOrder();
-                order.setcId(application.getOrderId());
-                order.setnStatus(8);
-                orderService.updateById(order);
-            }
-            // 审核时间
-            application.setAuditTime(LocalDateTime.now());
-            // 审核人ID
-            application.setAuditUserId(SecurityUtils.getUserId().toString());
-            // 审核人姓名
-            application.setAuditUserName(SecurityUtils.getUsername());
-            boolean b = cancelOrderApplicationService.updateById(application);
-            if (!b) {
-                return R.fail("审核退单申请失败");
-            }
-            return R.ok("审核退单申请成功");
-        } catch (Exception e) {
-            log.error("审核退单申请失败，申请ID：{}", cancelOrderApplication.getId(), e);
-            return R.fail("审核退单申请失败：" + e.getMessage());
-        }
+//        try {
+//            if (StringUtils.isBlank(cancelOrderApplication.getId())) {
+//                return R.fail("退单申请ID不能为空");
+//            }
+//            // 检查申请是否存在
+//            CancelOrderApplication application = cancelOrderApplicationService.getById(cancelOrderApplication.getId());
+//            if (application == null) {
+//                return R.fail("退单申请不存在");
+//            }
+//            //检查当前审核状态是否为待审核
+//            if (application.getAuditStatus() != 0) {
+//                return R.fail("退单申请当前状态不是待审核");
+//            }
+//
+//            // 审核退单申请
+//            application.setRefundAmount(cancelOrderApplication.getRefundAmount());
+//            application.setAuditRemark(cancelOrderApplication.getAuditRemark());
+//            application.setOrderStatus(8);
+//            application.setAuditStatus(cancelOrderApplication.getAuditStatus());
+//            // 审核通过，更新订单状态为退单审核通过
+//            if (application.getAuditStatus() == 1) {
+//                // 更新订单状态
+//                TOrder order = new TOrder();
+//                order.setcId(application.getOrderId());
+//                order.setnStatus(8);
+//                orderService.updateById(order);
+//            }
+//            // 审核时间
+//            application.setAuditTime(LocalDateTime.now());
+//            // 审核人ID
+//            application.setAuditUserId(SecurityUtils.getUserId().toString());
+//            // 审核人姓名
+//            application.setAuditUserName(SecurityUtils.getUsername());
+//            boolean b = cancelOrderApplicationService.updateById(application);
+//            if (!b) {
+//                return R.fail("审核退单申请失败");
+//            }
+//            return R.ok("审核退单申请成功");
+//        } catch (Exception e) {
+//            log.error("审核退单申请失败，申请ID：{}", cancelOrderApplication.getId(), e);
+//            return R.fail("审核退单申请失败：" + e.getMessage());
+//        }
+        return null;
     }
 
 

nightFragrance-admin/src/main/java/com/ylx/web/controller/massage/TFinancialIncomeController.java

@@ -43,7 +43,7 @@ public class TFinancialIncomeController extends BaseController {
         try {
             LoginUser loginUser = this.getLoginUser();
             log.info("登录用户信息：{}", JSON.toJSONString(loginUser));
-            order.setDeptId(loginUser.getDeptId().toString());
+//            order.setDeptId(loginUser.getDeptId().toString());
             Page<TOrder> all = orderService.getPcOrderIncome(page, order);
             return R.ok(all);
         } catch (Exception e) {
@@ -58,7 +58,7 @@ public class TFinancialIncomeController extends BaseController {
     public void export(HttpServletResponse response, Page<TOrder> page, TOrder param) {
         LoginUser loginUser = this.getLoginUser();
         log.info("登录用户信息：{}", JSON.toJSONString(loginUser));
-        param.setDeptId(loginUser.getDeptId().toString());
+//        param.setDeptId(loginUser.getDeptId().toString());
         Page<TOrder> all = orderService.getAll(page, param);
         ExcelUtil<TOrder> util = new ExcelUtil<>(TOrder.class);
         util.exportExcel(response, all.getRecords(), "订单");

nightFragrance-admin/src/main/java/com/ylx/web/controller/massage/TOrderController.java

@@ -36,6 +36,7 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -197,7 +198,7 @@ public class TOrderController extends BaseController {
     @RequestMapping(value = "wx/cancelApplyCancle", method = RequestMethod.POST)
     public R cancelApplyCancle(@RequestBody TOrder order) {
         try {
-            log.info("收到取消退单申请请求，订单ID：{}", order.getcId());
+            log.info("收到取消退单申请请求，订单ID：{}", order.getId());
             // 调用服务层处理取消退单申请
             orderService.cancelApplyCancle(order);
             // 返回成功提示
@@ -317,11 +318,11 @@ public class TOrderController extends BaseController {
             log.info("到达订单位置，order对象的值：{}", JSON.toJSONString(order));
 
             LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
-            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.DEPART.getCode());
-            order.setnStatus(OrderStatusEnum.ARRIVED.getCode());
-            order.setReachTime(LocalDateTime.now());
-            order.setArrivalLatitude(Optional.ofNullable(order.getArrivalLatitude()).orElse(BigDecimal.ZERO));
-            order.setArrivalLongitude(Optional.ofNullable(order.getArrivalLongitude()).orElse(BigDecimal.ZERO));
+//            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.DEPART.getCode());
+//            order.setnStatus(OrderStatusEnum.ARRIVED.getCode());
+//            order.setReachTime(LocalDateTime.now());
+//            order.setArrivalLatitude(Optional.ofNullable(order.getArrivalLatitude()).orElse(BigDecimal.ZERO));
+//            order.setArrivalLongitude(Optional.ofNullable(order.getArrivalLongitude()).orElse(BigDecimal.ZERO));
             order.setArrivalPhoto(Optional.ofNullable(order.getArrivalPhoto()).orElse(StringUtils.EMPTY));
             return R.ok(orderService.update(order, wrapper));
         } catch (ServiceException s) {
@@ -346,9 +347,9 @@ public class TOrderController extends BaseController {
     public R service(@RequestBody TOrder order) {
         try {
             LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
-            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.ARRIVED.getCode());
-            // 设置订单状态：服务中
-            order.setnStatus(OrderStatusEnum.SERVICE.getCode());
+//            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.ARRIVED.getCode());
+//            // 设置订单状态：服务中
+//            order.setnStatus(OrderStatusEnum.SERVICE.getCode());
             order.setStartTime(LocalDateTime.now());
             return R.ok(orderService.update(order, wrapper));
         } catch (ServiceException s) {
@@ -408,9 +409,10 @@ public class TOrderController extends BaseController {
     @ApiOperation("技师端-获取待接单数量")
     @RequestMapping(value = "wx/waitOrder", method = RequestMethod.GET)
     public R waitOrder(@RequestParam String cJsId) {
-        List<TOrder> list = orderService.list(new LambdaQueryWrapper<TOrder>().
-                eq(TOrder::getnStatus, OrderStatusEnum.WAIT_JD.getCode()).
-                eq(TOrder::getcJsId, cJsId));
+        List<TOrder> list = new ArrayList<>();
+//                List<TOrder> list = orderService.list(new LambdaQueryWrapper<TOrder>().
+//                eq(TOrder::getnStatus, OrderStatusEnum.WAIT_JD.getCode()).
+//                eq(TOrder::getcJsId, cJsId));
         return R.ok(list.size());
     }
 
@@ -429,7 +431,7 @@ public class TOrderController extends BaseController {
         try {
             LoginUser loginUser = this.getLoginUser();
             log.info("登录用户信息：{}", JSON.toJSONString(loginUser));
-            order.setDeptId(loginUser.getDeptId().toString());
+//            order.setDeptId(loginUser.getDeptId().toString());
             Page<TOrder> all = orderService.getAll(page, order);
             return R.ok(all);
         } catch (Exception e) {
@@ -458,9 +460,9 @@ public class TOrderController extends BaseController {
     @RequestMapping(value = "/select", method = RequestMethod.GET)
     public R selectSp(Page<TOrder> page, TOrder order) {
         LambdaQueryWrapper<TOrder> tOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        tOrderLambdaQueryWrapper.eq(StringUtils.isNotBlank(order.getcJsId()), TOrder::getcJsId, order.getcJsId()).
-                eq(StringUtils.isNotBlank(order.getcOpenId()), TOrder::getcOpenId, order.getcOpenId()).
-                eq(null != order.getnStatus(), TOrder::getnStatus, order.getnStatus());
+//        tOrderLambdaQueryWrapper.eq(StringUtils.isNotBlank(order.getcJsId()), TOrder::getcJsId, order.getcJsId()).
+//                eq(StringUtils.isNotBlank(order.getcOpenId()), TOrder::getcOpenId, order.getcOpenId()).
+//                eq(null != order.getnStatus(), TOrder::getnStatus, order.getnStatus());
         // 获取查询返回结果
         Page<TOrder> pageSelect = orderService.page(page, tOrderLambdaQueryWrapper);
         return R.ok(pageSelect);
@@ -500,7 +502,7 @@ public class TOrderController extends BaseController {
     @RequestMapping(value = "/del", method = RequestMethod.POST)
     public R del(@RequestBody TOrder borrow) {
         try {
-            log.info("删除订单ID：{}", borrow.getcId());
+            log.info("删除订单ID：{}", borrow.getId());
             return R.ok(orderService.removeById(borrow));
         } catch (Exception e) {
             e.printStackTrace();
@@ -518,7 +520,7 @@ public class TOrderController extends BaseController {
     @RequestMapping(value = "/getByid", method = RequestMethod.POST)
     public R<TOrder> getByid(@RequestBody TOrder borrow) {
         try {
-            return R.ok(orderService.getById(borrow.getcId()));
+            return R.ok(orderService.getById(borrow.getId()));
         } catch (Exception e) {
             e.printStackTrace();
             throw new RuntimeException(e);
@@ -619,7 +621,7 @@ public class TOrderController extends BaseController {
         LoginUser loginUser = this.getLoginUser();
         log.info("登录用户信息：{}", JSON.toJSONString(loginUser));
         TOrder order = new TOrder();
-        order.setDeptId(loginUser.getDeptId().toString());
+//        order.setDeptId(loginUser.getDeptId().toString());
         return R.ok(orderService.totalData(order));
     }
 

nightFragrance-admin/src/main/java/com/ylx/web/controller/massage/WeChatController.java

@@ -660,7 +660,7 @@ public class WeChatController extends BaseController {
         try {
             SMSVerificationCode smsVerificationCode = new SMSVerificationCode(String.valueOf(randNumber));
             String jsonString = JSON.toJSONString(smsVerificationCode);
-            sendSms.sendSms(phone, SendSmsEnum.SMS_220650023, jsonString);
+            sendSms.sendSms(phone, SendSmsEnum.SMS_220650024, jsonString);
             return R.ok("发送成功");
         } catch (Exception e) {
             e.printStackTrace();

nightFragrance-massage/src/main/java/com/ylx/massage/domain/vo/CancelOrderApplicationDetailVo.java

@@ -12,44 +12,44 @@ import java.math.BigDecimal;
 @Data
 public class CancelOrderApplicationDetailVo extends TOrder {
 
-    /**
-     * 退单申请ID
-     */
-    @JsonProperty(index = 0)
-    private String id;
-
-    /**
-     * 退单原因（申请备注）
-     */
-    private String cancelOrderReason;
-
-    /**
-     * 项目名称
-     */
-     private String projectName;
-
-    /**
-     * 项目时长
-     */
-     private Integer projectDuration;
-
-    /**
-     * 服务时长（分钟）
-     */
-     //private Integer serviceDuration;
-
-    /**
-     * 项目金额
-     */
-     private BigDecimal projectPrice;
-
-    /**
-     * 退款金额
-     */
-     private BigDecimal refundAmount;
-
-    /**
-     * 审核备注
-     */
-    private String auditRemark;
+//    /**
+//     * 退单申请ID
+//     */
+//    @JsonProperty(index = 0)
+//    private Long id;
+//
+//    /**
+//     * 退单原因（申请备注）
+//     */
+//    private String cancelOrderReason;
+//
+//    /**
+//     * 项目名称
+//     */
+//     private String projectName;
+//
+//    /**
+//     * 项目时长
+//     */
+//     private Integer projectDuration;
+//
+//    /**
+//     * 服务时长（分钟）
+//     */
+//     //private Integer serviceDuration;
+//
+//    /**
+//     * 项目金额
+//     */
+//     private BigDecimal projectPrice;
+//
+//    /**
+//     * 退款金额
+//     */
+//     private BigDecimal refundAmount;
+//
+//    /**
+//     * 审核备注
+//     */
+//    private String auditRemark;
 }

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/CancelOrderApplicationServiceImpl.java

@@ -1,26 +1,10 @@
 package com.ylx.massage.service.impl;
 
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.common.utils.StringUtils;
 import com.ylx.massage.domain.CancelOrderApplication;
-import com.ylx.massage.domain.TJs;
-import com.ylx.order.domain.TOrder;
-import com.ylx.massage.enums.OrderStatusEnum;
 import com.ylx.massage.service.CancelOrderApplicationService;
-import com.ylx.massage.service.TJsService;
-import com.ylx.order.service.TOrderService;
-import com.ylx.massage.service.TWxUserService;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.math.BigDecimal;
-import java.time.Duration;
-import java.time.LocalDateTime;
 
 /**
  * 退单申请服务实现类
@@ -34,328 +18,19 @@ public class CancelOrderApplicationServiceImpl
         extends ServiceImpl<com.ylx.massage.mapper.CancelOrderApplicationMapper, CancelOrderApplication>
         implements CancelOrderApplicationService {
 
-    @Autowired
-    private TOrderService orderService;
-
-    @Autowired
-    private TJsService jsService;
-
-    @Autowired
-    private TWxUserService wxUserService;
 
-    /**
-     * 创建退单申请
-     *
-     * @param orderId      订单ID
-     * @param cancelReason 退单原因
-     * @return String 申请记录ID
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public String createApplication(String orderId, String cancelReason) {
-        // 查询订单信息
-        TOrder order = orderService.getById(orderId);
-        if (order == null) {
-            throw new ServiceException("订单不存在");
-        }
-
-        // 校验订单状态 - 只有进行中的订单才能申请退单
-        // 进行中状态包括: 待接单(0)、已接单(1)、已出发(6)、已到达(2)、服务中(3)
-        Integer currentStatus = order.getnStatus();
-        log.info("订单当前状态：{}", currentStatus);
-        if (!isOrderInProgress(currentStatus)) {
-            throw new ServiceException("当前订单状态不允许申请退单，只有进行中的订单可以申请退单");
-        }
-
-        // 检查是否已有待审核的退单申请
-        CancelOrderApplication existingApplication = getInfoByOrderId(orderId);
-        if (existingApplication != null && existingApplication.getAuditStatus() == 0) {
-            throw new ServiceException("该订单已有待审核的退单申请，请勿重复提交");
-        }
-
-        // 查询技师信息
-        TJs technician = null;
-        if (StringUtils.isNotEmpty(order.getcJsId())) {
-            technician = jsService.getById(order.getcJsId());
-        }
-
-        // 构建退单申请记录
-        CancelOrderApplication application = new CancelOrderApplication();
-        application.setOrderId(order.getcId());
-        application.setOrderNo(order.getOrderNo());
-        application.setOpenId(order.getcOpenId());
-        application.setUserName(order.getcName());
-        application.setUserPhone(order.getcPhone());
-        application.setTechId(order.getcJsId());
-        application.setTechName(technician != null ? technician.getcName() : null);
-        application.setTechNickName(technician != null ? technician.getcNickName() : null);
-        // 设置技师手机号
-        application.setTechPhone(technician.getcPhone());
-
-        // 从订单明细中提取项目名称
-        String projectName = extractProjectName(order);
-        application.setProjectName(projectName);
-
-        // 提取并设置项目时长
-        Integer projectDuration = extractProjectDuration(order);
-        application.setProjectDuration(projectDuration != null ? String.valueOf(projectDuration) : "0");
-
-        // 计算已服务时长
-        Long serviceDuration = calculateServiceDuration(order);
-        application.setServiceDuration(String.valueOf(serviceDuration));
-
-        // 设置金额
-        application.setOrderAmount(order.getTotalPrice() != null ? order.getTotalPrice() : BigDecimal.ZERO);
-
-        // 计算退款金额
-        BigDecimal refundAmount = calculateRefundAmount(order, serviceDuration, projectDuration);
-        application.setRefundAmount(refundAmount);
-
-        // 保存订单原始状态，用于取消申请时恢复订单状态
-        application.setOrderStatus(currentStatus);
-
-        // 设置申请信息
-        application.setAuditStatus(0); // 0：待审核
-        application.setApplicationTime(LocalDateTime.now());
-        application.setCancelOrderReason(cancelReason);
-
-        // 设置创建时间
-        application.setCreateTime(LocalDateTime.now());
-        application.setUpdateTime(LocalDateTime.now());
-
-        // 8. 保存退单申请记录
-        boolean saved = this.save(application);
-        if (!saved) {
-            throw new ServiceException("创建退单申请失败");
-        }
-        log.info("退单申请创建成功，申请ID：{}，订单ID：{}", application.getId(), orderId);
-        return application.getId();
+        return "";
     }
 
-    /**
-     * 根据订单ID查询退单申请记录
-     *
-     * @param orderId 订单ID
-     * @return CancelOrderApplication 退单申请记录
-     */
     @Override
     public CancelOrderApplication getInfoByOrderId(String orderId) {
-        LambdaQueryWrapper<CancelOrderApplication> wrapper = new LambdaQueryWrapper<>();
-        wrapper.eq(CancelOrderApplication::getOrderId, orderId);
-        return this.getOne(wrapper);
-    }
-
-    /**
-     * 判断订单是否为进行中状态
-     * 进行中状态包括: 待接单(0)、已接单(1)、已出发(6)、已到达(2)、服务中(3)
-     *
-     * @param status 订单状态
-     * @return true-进行中，false-非进行中
-     */
-    private boolean isOrderInProgress(Integer status) {
-        return status != null &&
-                (status.equals(OrderStatusEnum.WAIT_JD.getCode()) || // 待接单
-                        status.equals(OrderStatusEnum.RECEIVED_ORDER.getCode()) || // 已接单
-                        status.equals(OrderStatusEnum.DEPART.getCode()) || // 已出发
-                        status.equals(OrderStatusEnum.ARRIVED.getCode()) || // 已到达
-                        status.equals(OrderStatusEnum.SERVICE.getCode())); // 服务中
-    }
-
-    /**
-     * 从订单中提取项目名称
-     *
-     * @param order 订单对象
-     * @return String 项目名称
-     */
-    private String extractProjectName(TOrder order) {
-        try {
-            if (order.getcGoods() != null && !order.getcGoods().isEmpty()) {
-                // cGoods是JSONArray，解析第一个项目的名称
-                return order.getcGoods().getJSONObject(0).getString("cTitle");
-            }
-        } catch (Exception e) {
-            log.warn("解析订单项目名称失败，订单ID：{}", order.getcId(), e);
-        }
         return null;
     }
 
-    /**
-     * 计算已服务时长（分钟）
-     *
-     * @param order 订单对象
-     * @return Long 已服务时长（分钟）
-     */
-    private Long calculateServiceDuration(TOrder order) {
-        try {
-            LocalDateTime startTime = order.getStartTime();
-            LocalDateTime endTime = order.getEndTime();
-
-            if (startTime != null && endTime != null) {
-                long minutes = Duration.between(startTime, endTime).toMinutes();
-                if (minutes > 0) {
-                    return minutes;
-                }
-            } else if (startTime != null) {
-                // 如果只有开始时间，计算到现在的时长
-                long minutes = Duration.between(startTime, LocalDateTime.now()).toMinutes();
-                if (minutes > 0) {
-                    return minutes;
-                }
-            }
-        } catch (Exception e) {
-            log.warn("计算服务时长失败，订单ID：{}", order.getcId(), e);
-        }
-        return 0L;
-    }
-
-    /**
-     * 从订单中提取项目时长（分钟）
-     *
-     * @param order 订单对象
-     * @return Integer 项目时长（分钟）
-     */
-    private Integer extractProjectDuration(TOrder order) {
-        try {
-            if (order.getcGoods() != null && !order.getcGoods().isEmpty()) {
-                long totalMinutes = 0;
-                for (int i = 0; i < order.getcGoods().size(); i++) {
-                    JSONObject item = order.getcGoods().getJSONObject(i);
-                    Integer minutes = item.getInteger("nMinute");
-                    Integer number = item.getInteger("number");
-                    if (minutes != null && number != null) {
-                        totalMinutes += (minutes * number);
-                    }
-                }
-                return (int) totalMinutes;
-            }
-        } catch (Exception e) {
-            log.warn("解析订单项目时长失败，订单ID：{}", order.getcId(), e);
-        }
-        return null;
-    }
-
-    /**
-     * 计算退款金额
-     * <p>
-     * 退款规则：
-     * （1）订单已接单状态：技师未出发，不需要填写退单申请即可退款，退款比例100%
-     * （2）订单已到达之前状态（待接单、已接单、已出发）：
-     * 1）免车费-需要填写退单申请，退款比例100%（自动带出，人工审核）
-     * 2）有车费-需要填写退单申请，退款金额=（项目金额-优惠金额）*100%+车费（自动带出，人工审核）
-     * （3）订单服务中：
-     * 1）免车费-需要填写退单申请，退款金额=（项目金额-优惠金额）*（服务时长/项目时长）100%（自动带出，人工审核）
-     * 2）有车费-需要填写退单申请，退款金额=（项目金额-优惠金额）*（服务时长/项目时长）100%+车费（自动带出，人工审核）
-     *
-     * @param order           订单对象
-     * @param serviceDuration 已服务时长（分钟）
-     * @param projectDuration 项目时长（分钟）
-     * @return BigDecimal 退款金额
-     */
-    private BigDecimal calculateRefundAmount(TOrder order, Long serviceDuration, Integer projectDuration) {
-        Integer orderStatus = order.getnStatus();
-        // 获取订单基础金额
-        // 项目金额
-        BigDecimal projectAmount = order.getdTotalMoney() != null ? order.getdTotalMoney() : BigDecimal.ZERO;
-        // 优惠金额
-        BigDecimal preferential = order.getPreferential() != null ? order.getPreferential() : BigDecimal.ZERO;
-        // 车费
-        BigDecimal fare = order.getFare() != null ? order.getFare() : BigDecimal.ZERO;
-
-        // 项目金额 - 优惠金额
-        BigDecimal projectAmountAfterDiscount = projectAmount.subtract(preferential);
-
-        // 判断是否有车费
-        boolean hasCarFee = fare.compareTo(BigDecimal.ZERO) > 0;
-
-        BigDecimal refundAmount = new BigDecimal("0");
-        if (OrderStatusEnum.RECEIVED_ORDER.getCode().equals(orderStatus)) {
-            // （1）订单已接单状态：技师未出发，退款比例100%
-            // 退款金额 = 项目金额 - 优惠金额 + 车费（如果有）
-            refundAmount = projectAmountAfterDiscount.add(fare);
-            log.info("订单已接单状态，退款金额=项目金额({})-优惠金额({})+车费({})={}", projectAmount, preferential, fare, refundAmount);
-        } else if (OrderStatusEnum.DEPART.getCode().equals(orderStatus)) {
-            // （2）订单已出发状态（已到达之前）
-            if (hasCarFee) {
-                //有车费：退款金额 = （项目金额 - 优惠金额）* 100% + 车费
-                refundAmount = projectAmountAfterDiscount.add(fare);
-                log.info("订单已出发状态且有车费，退款金额=（项目金额({})-优惠金额({}）*100%+车费({})={}", projectAmount, preferential, fare, refundAmount);
-            } else {
-                //免车费：退款比例100%
-                refundAmount = projectAmountAfterDiscount;
-                log.info("订单已出发状态且免车费，退款金额=（项目金额({})-优惠金额({}）*100%={}", projectAmount, preferential, refundAmount);
-            }
-        } else if (OrderStatusEnum.SERVICE.getCode().equals(orderStatus)) {
-            // （3）订单服务中
-            // 计算服务比例：服务时长 / 项目时长
-            double serviceRatio = (double) serviceDuration / projectDuration;
-            // 确保比例不超过1（不超过100%）
-            serviceRatio = Math.min(serviceRatio, 1.0);
-
-            // 计算退款金额
-            BigDecimal serviceRefundAmount = projectAmountAfterDiscount.multiply(BigDecimal.valueOf(serviceRatio)).setScale(2, BigDecimal.ROUND_HALF_UP);
-            if (hasCarFee) {
-                //有车费：退款金额 = （项目金额 - 优惠金额）*（服务时长/项目时长）100% + 车费
-                refundAmount = serviceRefundAmount.add(fare);
-                log.info("订单服务中且有车费，退款金额=（项目金额({})-优惠金额({}）*({}/{})*100%+车费({})={}", projectAmount, preferential, serviceDuration, projectDuration, fare, refundAmount);
-            } else {
-                //免车费：退款金额 = （项目金额 - 优惠金额）*（服务时长/项目时长）100%
-                refundAmount = serviceRefundAmount;
-                log.info("订单服务中且免车费，退款金额=（项目金额({})-优惠金额({}）*({}/{})*100%={}", projectAmount, preferential, serviceDuration, projectDuration, refundAmount);
-            }
-        }
-
-        // 确保退款金额不超过订单总价
-        BigDecimal maxRefund = order.getTotalPrice() != null ? order.getTotalPrice() : BigDecimal.ZERO;
-        if (refundAmount.compareTo(maxRefund) > 0) {
-            log.warn("计算退款金额({})超过订单总价({})，调整为订单总价", refundAmount, maxRefund);
-            refundAmount = maxRefund;
-        }
-        // 确保退款金额不为负数
-        if (refundAmount.compareTo(BigDecimal.ZERO) < 0) {
-            log.warn("计算退款金额({})为负数，调整为0", refundAmount);
-            refundAmount = BigDecimal.ZERO;
-        }
-        log.info("最终退款金额：{}，订单ID：{}，订单状态：{}，服务时长：{}分钟，项目时长：{}分钟", refundAmount, order.getcId(), orderStatus, serviceDuration, projectDuration);
-        return refundAmount;
-    }
-
-    /**
-     * 取消退单申请
-     * <p>
-     * 业务流程：
-     * 1. 验证退单申请是否存在
-     * 2. 验证退单申请状态是否为待审核（只有待审核的申请才能取消）
-     * 3. 更新退单申请记录的审核状态为已取消（使用 auditStatus = 3 表示用户主动取消）
-     * 4. 返回操作结果（订单状态的恢复由调用方 TOrderService 处理）
-     *
-     * @param orderId 订单ID
-     * @return Boolean 操作结果
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public Boolean cancelApplication(String orderId) {
-        log.info("开始取消退单申请，订单ID：{}", orderId);
-
-        // 1. 查询退单申请记录
-        CancelOrderApplication application = getInfoByOrderId(orderId);
-        if (application == null) {
-            throw new ServiceException("退单申请不存在");
-        }
-
-        // 2. 验证退单申请状态 - 只有待审核的申请才能取消
-        if (application.getAuditStatus() != 0) {
-            throw new ServiceException("当前退单申请状态不允许取消，只有待审核的申请可以取消");
-        }
-
-        // 3. 更新退单申请记录状态为已取消
-        // 使用 auditStatus = 3 表示用户主动取消（区别于审核拒绝的 2）
-        application.setAuditStatus(2);
-        application.setUpdateTime(LocalDateTime.now());
-        boolean updated = this.updateById(application);
-        if (!updated) {
-            throw new ServiceException("取消退单申请失败");
-        }
-        log.info("退单申请取消成功，订单ID：{}，申请ID：{}", orderId, application.getId());
-        return Boolean.TRUE;
+        return null;
     }
 }

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/OrderNotificationServiceImpl.java

@@ -1,24 +1,10 @@
 package com.ylx.massage.service.impl;
 
-import cn.hutool.json.JSONUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.ylx.common.config.WechatAccountConfig;
-import com.ylx.massage.domain.TJs;
-import com.ylx.order.domain.TOrder;
-import com.ylx.massage.domain.TXiangmu;
 import com.ylx.massage.service.OrderNotificationService;
-import com.ylx.massage.service.TJsService;
-import com.ylx.massage.utils.DateTimeUtils;
-import com.ylx.massage.utils.WeChatUtil;
+import com.ylx.order.domain.TOrder;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
-import javax.annotation.Resource;
-import java.time.LocalDateTime;
-import java.time.ZoneId;
-import java.util.Date;
-import java.util.List;
-
 /**
  * 订单消息通知服务实现类
  * <p>
@@ -34,316 +20,34 @@ import java.util.List;
 @Slf4j
 public class OrderNotificationServiceImpl implements OrderNotificationService {
 
-    @Resource
-    private WeChatUtil weChatUtil;
-
-    @Resource
-    private WechatAccountConfig wxPayProperties;
-
-    @Resource
-    private TJsService jsService;
-
-    /**
-     * 订单待接单提醒（技师侧）
-     *
-     * @param order 订单信息
-     */
-    @Override
-    public void sendPendingRemindNotification(TOrder order) {
-        try {
-            log.info("订单待接单提醒（技师侧）");
-            cn.hutool.json.JSONObject param = buildPendingRemindParams(order);
-            //获取技师openid
-            TJs js = jsService.getById(order.getcJsId());
-            weChatUtil.notification(js.getcOpenId(), wxPayProperties.getTechTemplate1(), param);
-            log.info("订单待接单提醒发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            log.error("订单待接单提醒发送失败，订单号：{}", order.getOrderNo(), e);
-        }
-    }
 
-    /**
-     * 订单已接单通知（用户侧）
-     *
-     * @param order 订单信息
-     */
     @Override
     public void sendReceivedNotification(TOrder order) {
-        try {
-            cn.hutool.json.JSONObject param = buildReceivedNotificationParams(order);
-            weChatUtil.notification(order.getcOpenId(), wxPayProperties.getUserTemplate1(), param);
-            log.info("订单已接单通知发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            e.printStackTrace();
-            log.error("订单已接单通知发送失败，订单号：{}", order.getOrderNo(), e);
-        }
+
     }
 
-    /**
-     * 订单完成通知（用户侧）
-     *
-     * @param order 订单信息
-     */
     @Override
     public void sendCompletedNotification(TOrder order) {
-        try {
-            cn.hutool.json.JSONObject param = buildCompletedNotificationParams(order);
-            weChatUtil.notification(order.getcOpenId(), wxPayProperties.getUserTemplate2(), param);
-            log.info("订单完成通知发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            log.error("订单完成通知发送失败，订单号：{}", order.getOrderNo(), e);
-        }
+
     }
 
-    /**
-     * 订单取消通知（用户侧）
-     *
-     * @param order 订单信息
-     */
     @Override
     public void sendCancelledNotification(TOrder order) {
-        try {
-            cn.hutool.json.JSONObject param = buildCancelledNotificationParams(order);
-            weChatUtil.notification(order.getcOpenId(), wxPayProperties.getUserTemplate3(), param);
-            log.info("订单取消通知发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            log.error("订单取消通知发送失败，订单号：{}", order.getOrderNo(), e);
-        }
-    }
-
-    /**
-     * 构建待接单提醒消息参数（技师侧）
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildPendingRemindParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单号
-        param.set("character_string9", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 用户电话
-        param.set("phone_number3", JSONUtil.createObj().set("value", order.getcPhone()));
-        // 项目
-        String projectNames = getProjectNames(order);
-        param.set("thing10", JSONUtil.createObj().set("value", projectNames));
-        // 下单地址
-        param.set("thing13", JSONUtil.createObj().set("value", order.getAddress()));
-        // 预约时间
-        LocalDateTime startTime = order.getStartTime();
-        if(startTime==null){
-            // 预约时间为空，设置默认值
-            startTime = LocalDateTime.now();
-        }
-        Date date = Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant());
-        param.set("time6", JSONUtil.createObj().set("value", DateTimeUtils.formatDate(date, "yyyy-MM-dd HH:mm")));
-        return param;
-    }
 
-    /**
-     * 构建已接单通知消息参数
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildReceivedNotificationParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单号
-        param.set("character_string1", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 项目名称
-        String projectNames = getProjectNames(order);
-        param.set("thing4", JSONUtil.createObj().set("value", projectNames));
-
-        //根据技师ID查询技师姓名
-        TJs js = jsService.getById(order.getcJsId());
-        String jsName = js.getcName();
-        // 商家名称
-        param.set("thing9", JSONUtil.createObj().set("value", jsName));
-        // 联系电话
-        param.set("phone_number5", JSONUtil.createObj().set("value", js.getcPhone()));
-        return param;
-    }
-
-    /**
-     * 构建完成通知消息参数（用户侧）
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildCompletedNotificationParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单号
-        param.set("character_string8", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 项目名称
-        String projectNames = getProjectNames(order);
-        param.set("thing19", JSONUtil.createObj().set("value", projectNames));
-        // 完成时间
-        LocalDateTime completeTime = order.getEndTime();
-        Date date = Date.from(completeTime.atZone(ZoneId.systemDefault()).toInstant());
-        param.set("time18", JSONUtil.createObj().set("value", DateTimeUtils.formatDate(date, "yyyy-MM-dd HH:mm")));
-        return param;
     }
 
-    /**
-     * 构建取消通知消息参数
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildCancelledNotificationParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单号
-        param.set("character_string2", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 取消原因
-        param.set("thing5", JSONUtil.createObj().set("value", "用户个人原因"));
-        // 项目名称
-        String projectNames = getProjectNames(order);
-        param.set("thing25", JSONUtil.createObj().set("value", projectNames));
-        //订单金额
-        param.set("amount23", JSONUtil.createObj().set("value", order.getTotalPrice().toString()));
-        return param;
-    }
+    @Override
+    public void sendPendingRemindNotification(TOrder order) {
 
-    /**
-     * 从订单明细中提取项目名称
-     * <p>
-     * 解析订单的商品列表，将多个项目名称用逗号连接
-     * </p>
-     *
-     * @param order 订单信息
-     * @return String 项目名称字符串，多个项目用逗号分隔
-     */
-    private String getProjectNames(TOrder order) {
-        List<TXiangmu> list = JSONObject.parseArray(order.getcGoods().toJSONString(), TXiangmu.class);
-        StringBuilder sb = new StringBuilder();
-        for (TXiangmu xiangmu : list) {
-            sb.append(xiangmu.getcTitle()).append(",");
-        }
-        // 移除最后一个逗号
-        if (sb.length() > 0) {
-            sb.setLength(sb.length() - 1);
-        }
-        return sb.toString();
     }
 
-    /**
-     * 订单已接单通知（技师侧）
-     *
-     * @param order 订单信息
-     */
     @Override
     public void sendTechnicianReceivedNotification(TOrder order) {
-        try {
-            // 获取技师信息
-            String jsOpenId = getTechnicianOpenId(order);
-            log.info("技师的openId：{}", jsOpenId);
-            if (jsOpenId == null) {
-                log.warn("技师信息不存在，无法发送已接单通知，订单号：{}", order.getOrderNo());
-                return;
-            }
 
-            cn.hutool.json.JSONObject param = buildTechnicianReceivedNotificationParams(order);
-            weChatUtil.notification(jsOpenId, wxPayProperties.getTechTemplate2(), param);
-            log.info("技师侧已接单通知发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            log.error("技师侧已接单通知发送失败，订单号：{}", order.getOrderNo(), e);
-        }
     }
 
-    /**
-     * 订单取消通知（技师侧）
-     *
-     * @param order 订单信息
-     */
     @Override
     public void sendTechnicianCancelledNotification(TOrder order) {
-        try {
-            // 获取技师的openId
-            String jsOpenId = getTechnicianOpenId(order);
-            log.info("技师的openId：{}", jsOpenId);
-            if (jsOpenId == null) {
-                log.warn("技师信息不存在，无法发送取消通知，订单号：{}", order.getOrderNo());
-                return;
-            }
-
-            cn.hutool.json.JSONObject param = buildTechnicianCancelledNotificationParams(order);
-            weChatUtil.notification(jsOpenId, wxPayProperties.getTechTemplate3(), param);
-            log.info("技师侧取消订单通知发送成功，订单号：{}", order.getOrderNo());
-        } catch (Exception e) {
-            log.error("技师侧取消订单通知发送失败，订单号：{}", order.getOrderNo(), e);
-        }
-    }
-
-    /**
-     * 构建技师侧已接单通知消息参数
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildTechnicianReceivedNotificationParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单编号
-        param.set("character_string1", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 联系电话
-        param.set("phone_number5", JSONUtil.createObj().set("value", order.getcPhone()));
-        // 项目名称
-        String projectNames = getProjectNames(order);
-        param.set("thing4", JSONUtil.createObj().set("value", projectNames));
-        // 预约地址
-        param.set("thing14", JSONUtil.createObj().set("value", order.getAddress()));
-        // 预约时间
-        LocalDateTime dtCreateTime = order.getDtCreateTime();
-        Date createTime = Date.from(dtCreateTime.atZone(ZoneId.systemDefault()).toInstant());
-        param.set("time3", JSONUtil.createObj().set("value", DateTimeUtils.formatDate(createTime, "yyyy-MM-dd HH:mm")));
-        return param;
-    }
-
-    /**
-     * 构建技师侧取消通知消息参数
-     *
-     * @param order 订单信息
-     * @return JSONObject 消息参数
-     */
-    private cn.hutool.json.JSONObject buildTechnicianCancelledNotificationParams(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        // 订单号
-        param.set("character_string2", JSONUtil.createObj().set("value", order.getOrderNo()));
-        // 取消原因
-        param.set("thing5", JSONUtil.createObj().set("value", getCancelReason(order)));
-        // 订单金额
-        param.set("amount23", JSONUtil.createObj().set("value", order.getTotalPrice().toString()));
-        return param;
-    }
-
-    /**
-     * 获取技师的 OpenId
-     *
-     * @param order 订单信息
-     * @return String 技师 OpenId，如果技师不存在则返回 null
-     */
-    private String getTechnicianOpenId(TOrder order) {
-        if (order.getcJsId() == null) {
-            return null;
-        }
-        try {
-            return jsService.getById(order.getcJsId()).getcOpenId();
-        } catch (Exception e) {
-            log.error("获取技师信息失败，技师ID：{}", order.getcJsId(), e);
-            return null;
-        }
-    }
 
-    /**
-     * 获取订单取消原因
-     *
-     * @param order 订单信息
-     * @return String 取消原因描述
-     */
-    private String getCancelReason(TOrder order) {
-        // 如果订单中有具体的取消原因，使用订单中的原因
-        if (order.getReasonRefusal() != null && !order.getReasonRefusal().trim().isEmpty()) {
-            return order.getReasonRefusal();
-        }
-        // 默认取消原因
-        return "用户取消订单";
     }
 }

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/OrderValidationServiceImpl.java

@@ -1,292 +0,0 @@
-package com.ylx.massage.service.impl;
-
-import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.order.domain.TOrder;
-import com.ylx.massage.enums.OrderStatusEnum;
-import com.ylx.massage.service.OrderValidationService;
-import com.ylx.order.service.TOrderService;
-import com.ylx.massage.utils.OrderTimeRangeUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Service;
-
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * 订单校验服务实现类
- * <p>
- * 实现订单创建和接单时的校验功能，基于订单状态锁机制。
- * 确保技师服务时间的互斥性，防止冲突订单的产生。
- * </p>
- *
- * @author ylx
- * @version 1.0
- * @since 2024
- */
-@Service
-public class OrderValidationServiceImpl implements OrderValidationService {
-
-    private static final Logger log = LoggerFactory.getLogger(OrderValidationServiceImpl.class);
-
-    /**
-     * 进行中的订单状态列表
-     * 包括：待接单、已接单、已出发、已到达、服务中
-     */
-    private static final List<Integer> IN_PROGRESS_STATUSES = Arrays.asList(
-            OrderStatusEnum.WAIT_JD.getCode(),       // 0 - 待接单
-        OrderStatusEnum.RECEIVED_ORDER.getCode(), // 1 - 已接单
-            OrderStatusEnum.DEPART.getCode(),      // 6 - 已出发
-        OrderStatusEnum.ARRIVED.getCode(),        // 2 - 已到达
-        OrderStatusEnum.SERVICE.getCode()         // 3 - 服务中
-    );
-
-    private final TOrderService orderService;
-
-    public OrderValidationServiceImpl(TOrderService orderService) {
-        this.orderService = orderService;
-    }
-
-    /**
-     * 检查技师是否可以接单
-     * <p>
-     * 基于订单状态锁机制和时间范围校验，检查技师是否有进行中的订单。
-     * 如果技师有进行中的订单，进一步检查时间范围是否重叠。
-     * </p>
-     * <p>
-     * 时间范围校验逻辑：
-     * 1. 如果现有订单有明确的时间范围（开始时间、结束时间），检查是否与新订单重叠
-     * 2. 如果现有订单时间信息不完整，采用保守策略，拒绝接单
-     * 3. 考虑30分钟缓冲时间，在两个订单之间留出缓冲期
-     * </p>
-     *
-     * @param technicianId 技师ID
-     * @param newOrder 新订单信息
-     * @return boolean true-可以接单
-     * @throws ServiceException 当技师不能接单时抛出异常
-     */
-    @Override
-    public boolean canAcceptOrder(String technicianId, TOrder newOrder) {
-        // 1. 参数校验
-        if (StrUtil.isBlank(technicianId)) {
-            throw new ServiceException("技师ID不能为空");
-        }
-
-        // 2. 升级订单特殊处理（升级订单可以创建）
-        if (OrderTimeRangeUtils.isUpgradeOrder(newOrder)) {
-            log.info("升级订单，跳过互斥校验，订单号：{}", newOrder.getOrderNo());
-            return true;
-        }
-
-        // 3. 查询技师的进行中订单
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getcJsId, technicianId)
-                .in(TOrder::getnStatus, IN_PROGRESS_STATUSES)
-                .eq(TOrder::getIsDelete, 0);
-
-        List<TOrder> inProgressOrders = orderService.list(queryWrapper);
-
-        // 4. 如果没有进行中的订单，可以接单
-        if (inProgressOrders == null || inProgressOrders.isEmpty()) {
-            log.info("技师 {} 没有进行中的订单，可以接单", technicianId);
-            return true;
-        }
-
-        // 5. 有进行中的订单，进一步检查时间范围
-        log.info("技师 {} 有 {} 个进行中的订单，开始时间范围校验", technicianId, inProgressOrders.size());
-
-        //新订单的开始和结束时间
-        /*LocalDateTime newOrderStart = OrderTimeRangeUtils.estimateStartTime(newOrder);
-        LocalDateTime newOrderEnd = OrderTimeRangeUtils.estimateEndTime(newOrder);*/
-        String startTimeStr = newOrder.getStartTimeStr();
-        LocalDateTime newOrderStart = LocalDateTime.parse(startTimeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
-        String endTimeStr = newOrder.getEndTimeStr();
-        LocalDateTime newOrderEnd = LocalDateTime.parse(endTimeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
-
-        // 创建临时订单对象用于时间范围校验
-        TOrder newOrderWithTime = new TOrder();
-        newOrderWithTime.setcGoods(newOrder.getcGoods());
-        newOrderWithTime.setStartTime(newOrderStart);
-        newOrderWithTime.setEndTime(newOrderEnd);
-
-        // 遍历所有进行中的订单，检查时间范围是否重叠
-        for (TOrder existingOrder : inProgressOrders) {
-            if (OrderTimeRangeUtils.isTimeRangeOverlapping(newOrderWithTime, existingOrder)) {
-                // 时间范围重叠，构建详细错误信息
-                String message = buildTimeConflictMessage(existingOrder, newOrderWithTime);
-                log.warn("技师 {} 无法接单，原因：{}", technicianId, message);
-                throw new ServiceException(message);
-            }
-        }
-
-        // 6. 所有进行中的订单都与新订单时间不冲突，可以接单
-        log.info("技师 {} 所有进行中订单的时间范围与新订单不冲突，可以接单", technicianId);
-        return true;
-    }
-
-    /**
-     * 检查技师是否可以被手动分配订单
-     * <p>
-     * 用于后台管理员手动分配订单的场景。
-     * 与接单校验逻辑相同，技师不能有进行中的订单，且时间范围不能重叠。
-     * </p>
-     *
-     * @param technicianId 技师ID
-     * @return true-可以分配
-     * @throws ServiceException 当技师不能被分配订单时抛出异常
-     */
-    @Override
-    public boolean canManualAssign(String technicianId) {
-        // 1. 参数校验
-        if (StrUtil.isBlank(technicianId)) {
-            throw new ServiceException("技师ID不能为空");
-        }
-
-        // 2. 查询技师的进行中订单
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getcJsId, technicianId)
-                .in(TOrder::getnStatus, IN_PROGRESS_STATUSES)
-                .eq(TOrder::getIsDelete, 0);
-
-        List<TOrder> inProgressOrders = orderService.list(queryWrapper);
-
-        // 3. 如果没有进行中的订单，可以分配
-        if (inProgressOrders == null || inProgressOrders.isEmpty()) {
-            log.info("技师 {} 没有进行中的订单，可以手动分配订单", technicianId);
-            return true;
-        }
-
-        // 4. 有进行中的订单，检查时间范围
-        log.info("技师 {} 有 {} 个进行中的订单，无法手动分配", technicianId, inProgressOrders.size());
-
-        TOrder currentOrder = inProgressOrders.get(0);
-        String statusDesc = OrderStatusEnum.getDescByCode(currentOrder.getnStatus());
-
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
-        StringBuilder message = new StringBuilder();
-        message.append(String.format("该技师当前有%s的订单（订单号：%s），无法手动分配。\n",
-            statusDesc, currentOrder.getOrderNo()));
-
-        // 添加时间信息
-        if (currentOrder.getStartTime() != null) {
-            message.append("开始时间：").append(currentOrder.getStartTime().format(formatter)).append("\n");
-        }
-        if (currentOrder.getEndTime() != null) {
-            message.append("结束时间：").append(currentOrder.getEndTime().format(formatter)).append("\n");
-        }
-
-        message.append("请等待当前订单完成后再试。");
-
-        log.warn("技师 {} 无法手动分配订单，原因：{}", technicianId, message);
-        throw new ServiceException(message.toString());
-    }
-
-    /**
-     * 获取技师的进行中订单数量
-     * <p>
-     * 统计技师当前进行中的订单数量。
-     * 用于前端展示技师状态和负载情况。
-     * </p>
-     *
-     * @param technicianId 技师ID
-     * @return 进行中的订单数量
-     */
-    @Override
-    public long getInProgressOrderCount(String technicianId) {
-        if (StrUtil.isBlank(technicianId)) {
-            return 0;
-        }
-
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getcJsId, technicianId)
-                .in(TOrder::getnStatus, IN_PROGRESS_STATUSES)
-                .eq(TOrder::getIsDelete, 0);
-
-        return orderService.count(queryWrapper);
-    }
-
-    /**
-     * 检查订单是否可以支付
-     * <p>
-     * 防止在订单状态发生变化后仍然可以支付。
-     * 只有待付款状态的订单才可以支付。
-     * </p>
-     *
-     * @param orderNo 订单号
-     * @return true-可以支付
-     * @throws ServiceException 当订单不可支付时抛出异常
-     */
-    @Override
-    public boolean canPayOrder(String orderNo) {
-        if (StrUtil.isBlank(orderNo)) {
-            throw new ServiceException("订单号不能为空");
-        }
-
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getOrderNo, orderNo)
-                .eq(TOrder::getIsDelete, 0);
-
-        TOrder order = orderService.getOne(queryWrapper);
-
-        if (order == null) {
-            throw new ServiceException("订单不存在");
-        }
-
-        // 只有待付款状态可以支付
-        if (!OrderStatusEnum.WAIT_PAY.getCode().equals(order.getnStatus())) {
-            String currentStatus = OrderStatusEnum.getDescByCode(order.getnStatus());
-            throw new ServiceException(
-                String.format("订单当前状态为【%s】，无法支付。只有待付款状态的订单才可以支付。", currentStatus)
-            );
-        }
-
-        return true;
-    }
-
-    /**
-     * 构建时间冲突的详细错误信息
-     * <p>
-     * 当检测到时间范围重叠时，生成包含详细时间信息的错误消息。
-     * </p>
-     *
-     * @param existingOrder 现有订单
-     * @param newOrder 新订单
-     * @return String 错误信息
-     */
-    private String buildTimeConflictMessage(TOrder existingOrder, TOrder newOrder) {
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
-        StringBuilder message = new StringBuilder();
-        message.append("该技师当前有进行中的订单，时间冲突。");
-
-        // 现有订单信息
-        message.append("现有订单：").append(existingOrder.getOrderNo()).append("\n");
-        if (existingOrder.getStartTime() != null) {
-            message.append("  开始时间：").append(existingOrder.getStartTime().format(formatter)).append("\n");
-        }
-        if (existingOrder.getEndTime() != null) {
-            message.append("  结束时间：").append(existingOrder.getEndTime().format(formatter)).append("\n");
-        }
-
-        String statusDesc = OrderStatusEnum.getDescByCode(existingOrder.getnStatus());
-        message.append("  订单状态：").append(statusDesc).append("\n");
-
-        // 新订单信息
-        message.append("新订单：").append(newOrder.getOrderNo()).append(" ");
-        if (newOrder.getStartTime() != null) {
-            message.append("  预计开始时间：").append(newOrder.getStartTime().format(formatter)).append("\n");
-        }
-        if (newOrder.getEndTime() != null) {
-            message.append("  预计结束时间：").append(newOrder.getEndTime().format(formatter)).append("\n");
-        }
-        // 提示用户
-        Long durationMinutes = OrderTimeRangeUtils.calculateOrderDuration(newOrder);
-        if (durationMinutes != null) {
-            message.append(" 建议：请等待当前订单完成后再试，或选择其他时间段（需间隔至少30分钟）。");
-        }
-        return message.toString();
-    }
-}

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/TCommentServiceImpl.java

@@ -2,19 +2,10 @@ package com.ylx.massage.service.impl;
 
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.ylx.common.core.domain.model.WxLoginUser;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.common.utils.StringUtils;
 import com.ylx.massage.domain.TComment;
-import com.ylx.order.domain.TOrder;
-import com.ylx.massage.enums.OrderStatusEnum;
 import com.ylx.massage.mapper.TCommentMapper;
 import com.ylx.massage.service.TCommentService;
-import com.ylx.order.service.TOrderService;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import javax.annotation.Resource;
-import java.time.LocalDateTime;
 
 
 /**
@@ -23,37 +14,8 @@ import java.time.LocalDateTime;
 @Service
 public class TCommentServiceImpl extends ServiceImpl<TCommentMapper, TComment> implements TCommentService {
 
-    @Resource
-    private TOrderService orderService;
-
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public Boolean saveComment(TComment comment, WxLoginUser wxLoginUser) {
-
-        if(StringUtils.isBlank(comment.getOrderNo())){
-            throw new ServiceException("订单号不能为空");
-        }
-        if(StringUtils.isBlank(comment.getOrderId())){
-            throw new ServiceException("订单id不能为空");
-        }
-        if(StringUtils.isBlank(comment.getcJsid())){
-            throw new ServiceException("技师id不能空");
-        }
-        if(StringUtils.isBlank(comment.getcText())){
-            throw new ServiceException("评论内容不能空");
-        }
-        if(StringUtils.isBlank(comment.getName())){
-            throw new ServiceException("技师姓名不能空");
-        }
-        comment.setcIcon(wxLoginUser.getCIcon());
-        comment.setcNickName(wxLoginUser.getCNickName());
-        comment.setcOpenId(wxLoginUser.getCOpenid());
-        comment.setdTime(LocalDateTime.now());
-        this.save(comment);
-        TOrder order = new TOrder();
-        //修改订单状态（已完成以评论）
-        order.setnStatus(OrderStatusEnum.COMPLETE.getCode());
-        order.setcId(comment.getOrderId());
-        return orderService.updateById(order);
+        return null;
     }
 }

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/TCommentUserServiceImpl.java

@@ -1,38 +1,14 @@
 package com.ylx.massage.service.impl;
 
-import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.ylx.common.core.domain.model.WxLoginUser;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.common.utils.StringUtils;
-import com.ylx.lottery.domain.LotteryCountLog;
-import com.ylx.lottery.domain.vo.LocalActivityTableVO;
-import com.ylx.lottery.domain.vo.LotteryActivityVO;
-import com.ylx.lottery.service.LotteryCountLogService;
-import com.ylx.lottery.service.LotteryCountService;
-import com.ylx.massage.domain.CommentUserAudit;
 import com.ylx.massage.domain.TCommentUser;
-import com.ylx.order.domain.TOrder;
-import com.ylx.massage.domain.TWxUser;
-import com.ylx.massage.enums.OrderStatusEnum;
 import com.ylx.massage.mapper.TCommentUserMapper;
-import com.ylx.massage.service.TCommentUserAuditService;
 import com.ylx.massage.service.TCommentUserService;
-import com.ylx.order.service.TOrderService;
-import com.ylx.massage.service.TWxUserService;
-import com.ylx.point.domain.dto.ApiAddPointsDTO;
-import com.ylx.point.service.IPointAccountService;
-import com.ylx.usercenter.domain.dto.UnifiedUserCenterDTO;
-import com.ylx.usercenter.service.UnifiedUserCenterService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.support.TransactionSynchronization;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
 
-import javax.annotation.Resource;
-import java.util.Date;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -45,183 +21,13 @@ import java.util.List;
 @Service("tCommentUserService")
 public class TCommentUserServiceImpl extends ServiceImpl<TCommentUserMapper, TCommentUser> implements TCommentUserService {
 
-    @Resource
-    private TOrderService orderService;
-
-    @Resource
-    private TCommentUserAuditService commentUserAuditService;
-
-    @Resource
-    private TCommentUserMapper tCommentUserMapper;
-    @Resource
-    private LotteryCountService lotteryCountService;
-    @Resource
-    private LotteryCountLogService lotteryCountLogService;
-    @Resource
-    private UnifiedUserCenterService unifiedUserCenterService;
-    @Resource
-    private IPointAccountService pointAccountService;
-    @Resource
-    private TWxUserService wxUserService;
-
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public Boolean saveComment(TCommentUser comment, WxLoginUser wxLoginUser) {
-        //订单ID不能为空
-        if (StringUtils.isBlank(comment.getOrderId())) {
-            throw new ServiceException("订单id不能为空");
-        }
-        //判断订单是否存在
-        TOrder order1 = orderService.getById(comment.getOrderId());
-        if (order1 == null) {
-            throw new ServiceException("订单不存在");
-        }
-        if (StringUtils.isBlank(comment.getOrderNo())) {
-            throw new ServiceException("订单号不能为空");
-        }
-        if (StringUtils.isBlank(comment.getText())) {
-            throw new ServiceException("评论内容不能空");
-        }
-        if (StringUtils.isBlank(comment.getJsId())) {
-            throw new ServiceException("技师id不能空");
-        }
-        if (StringUtils.isBlank(comment.getName())) {
-            throw new ServiceException("技师姓名不能空");
-        }
-        comment.setOpenId(wxLoginUser.getCOpenid());
-        //comment.setOpenId("o-HEJ6RAjBDjFvuZcAdHRX8mIZXw");
-        comment.setCommentTime(new Date());
-        this.save(comment);
-
-        //向用户评论审核表中插入数据
-        CommentUserAudit commentUserAudit = new CommentUserAudit();
-        commentUserAudit.setCommentId(comment.getId());
-        commentUserAudit.setOrderNo(comment.getOrderNo());
-        commentUserAudit.setText(comment.getText());
-        //默认审核状态为待审核
-        commentUserAudit.setAuditStatus(0);
-        commentUserAudit.setCreateTime(new Date());
-        commentUserAudit.setUpdateTime(new Date());
-        commentUserAudit.setIsDelete(0);
-        commentUserAuditService.save(commentUserAudit);
-
-        TOrder order = new TOrder();
-        //修改订单状态（已完成）
-        order.setnStatus(OrderStatusEnum.COMPLETE.getCode());
-        order.setcId(comment.getOrderId());
-        boolean updateOrderSuccess = orderService.updateById(order);
-        if (!updateOrderSuccess) {
-            throw new ServiceException("订单状态更新失败");
-        }
-
-        // 评价有礼 —— 发放抽奖次数日志
-        grantLotteryCountForComment(wxLoginUser);
-
-        // 已绑定一账通 → 异步同步抽奖次数
-        syncLotteryCountIfNeeded(wxLoginUser.getId());
-
-        return true;
+        return null;
     }
 
     @Override
     public List<TCommentUser> selectAll(TCommentUser tCommentUser) {
-        return tCommentUserMapper.selectAll(tCommentUser);
-    }
-
-    /**
-     * 评价有礼发放抽奖次数
-     */
-    private void grantLotteryCountForComment(WxLoginUser wxLoginUser) {
-        List<LotteryActivityVO> activityList = lotteryCountService.queryActivityRules();
-        if (CollUtil.isEmpty(activityList)) {
-            return;
-        }
-
-        for (LotteryActivityVO activity : activityList) {
-            // 处理积分表
-            List<LocalActivityTableVO> pointTables = activity.getGyyPointTables();
-            if (CollUtil.isNotEmpty(pointTables)) {
-                for (LocalActivityTableVO table : pointTables) {
-                    ApiAddPointsDTO dto = new ApiAddPointsDTO();
-                    dto.setUserId(wxLoginUser.getId());
-                    dto.setPoints(table.getPointNumber());
-                    pointAccountService.apiAddPoints(dto);
-                }
-            }
-
-            // 非积分表、任务奖励类型（参与规则=3）
-            if (ObjectUtil.notEqual(activity.getParticipationRules(), 3)) {
-                continue;
-            }
-
-            List<LocalActivityTableVO> localTables = activity.getLocalActivityTables();
-            if (CollUtil.isEmpty(localTables)) {
-                continue;
-            }
-
-            String activityUrl = activity.getActivityUrl();
-
-            // 类型=4 → 评价有礼
-            for (LocalActivityTableVO table : localTables) {
-                if (ObjectUtil.equals(table.getType(), "4")) {
-                    table.setActivityUrl(activityUrl);
-                    table.setActivityId(activity.getId());
-                    saveLotteryLog(wxLoginUser, table, 1);
-                }
-            }
-        }
-    }
-
-    /**
-     * 统一保存抽奖次数日志
-     */
-    private void saveLotteryLog(WxLoginUser wxLoginUser, LocalActivityTableVO table, Integer lotteryNum) {
-        LotteryCountLog log = new LotteryCountLog();
-        log.setOpenId(wxLoginUser.getCOpenid());
-        log.setUserId(wxLoginUser.getId());
-        log.setUserPhone(wxLoginUser.getCPhone());
-        log.setActivityType(2); // 任务奖励
-        log.setLocalActivityTableId(table.getActivityId());
-        log.setLotteryNum(lotteryNum);
-        log.setReceiveTime(new Date());
-        log.setIsDelete("0");
-        log.setStatus(0); // 未同步
-        log.setIsLottery(0);
-        log.setType(3);
-        log.setActivityUrl(table.getActivityUrl());
-        lotteryCountLogService.save(log);
-    }
-
-    private void syncLotteryCountIfNeeded(String id) {
-
-        // 避免用户绑定本地生活用户后，token中数据未能更新，导致不能同步抽奖次数
-        TWxUser user = this.wxUserService.getById(id);
-        if (ObjectUtil.isNull(user)) {
-            throw new ServiceException("用户不存在");
-        }
-
-        if (ObjectUtil.equals(user.getIsBind(), 1)
-                && StringUtils.isNotBlank(user.getLocalLiveUserId())) {
-
-            UnifiedUserCenterDTO dto = new UnifiedUserCenterDTO();
-            dto.setSourceUserId(user.getLocalLiveUserId());
-            dto.setTargetUserId(user.getId());
-
-            // 👇 加上这个 if 判断，只有当当前存在活跃事务时，才去注册 afterCommit 回调
-            if (TransactionSynchronizationManager.isSynchronizationActive()) {
-                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
-                    @Override
-                    public void afterCommit() {
-                        // 事务提交完成！现在调用异步，一定能查到数据
-                        unifiedUserCenterService.syncLotteryCount(dto);
-                    }
-                });
-            } else {
-                // 👇 兜底逻辑：如果事务没开启（比如同类自调用导致失效），就直接同步执行，避免报错
-                log.warn("当前没有活跃事务，无法注册 afterCommit 回调，将直接同步执行抽奖次数同步！");
-                unifiedUserCenterService.syncLotteryCount(dto);
-            }
-
-        }
+        return Collections.emptyList();
     }
 }

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/YlxAlarmServiceImpl.java

@@ -1,27 +1,14 @@
 package com.ylx.massage.service.impl;
 
 
-import cn.hutool.core.collection.CollectionUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.common.utils.StringUtils;
-import com.ylx.massage.domain.TJs;
-import com.ylx.order.domain.TOrder;
 import com.ylx.massage.domain.YlxAlarm;
-import com.ylx.massage.enums.OrderStatusEnum;
 import com.ylx.massage.mapper.YlxAlarmMapper;
-import com.ylx.massage.service.TJsService;
-import com.ylx.order.service.TOrderService;
 import com.ylx.massage.service.YlxAlarmService;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
 import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.PageRequest;
-
-import javax.annotation.Resource;
-import java.util.List;
+import org.springframework.stereotype.Service;
 
 /**
  * 报警记录表(YlxAlarm)表服务实现类
@@ -32,103 +19,29 @@ import java.util.List;
 @Slf4j
 @Service("ylxAlarmService")
 public class YlxAlarmServiceImpl extends ServiceImpl<YlxAlarmMapper, YlxAlarm> implements YlxAlarmService {
-    @Resource
-    private YlxAlarmMapper ylxAlarmDao;
-
-    @Resource
-    private TOrderService orderService;
 
-    @Resource
-    private TJsService jsService;
-
-    /**
-     * 通过ID查询单条数据
-     *
-     * @param id 主键
-     * @return 实例对象
-     */
     @Override
     public YlxAlarm queryById(String id) {
-        return this.ylxAlarmDao.queryById(id);
+        return null;
     }
 
-    /**
-     * 分页查询
-     *
-     * @param ylxAlarm    筛选条件
-     * @param pageRequest 分页对象
-     * @return 查询结果
-     */
     @Override
     public Page<YlxAlarm> queryByPage(YlxAlarm ylxAlarm, PageRequest pageRequest) {
-        long total = this.ylxAlarmDao.count(ylxAlarm);
-        return new PageImpl<>(this.ylxAlarmDao.queryAllByLimit(ylxAlarm, pageRequest), pageRequest, total);
+        return null;
     }
 
-    /**
-     * 新增数据
-     *
-     * @param ylxAlarm 实例对象
-     * @return 实例对象
-     */
-
-    /**
-     * 修改数据
-     *
-     * @param ylxAlarm 实例对象
-     * @return 实例对象
-     */
     @Override
     public YlxAlarm update(YlxAlarm ylxAlarm) {
-        this.ylxAlarmDao.update(ylxAlarm);
-        return this.queryById(ylxAlarm.getId());
+        return null;
     }
 
-    /**
-     * 通过主键删除数据
-     *
-     * @param id 主键
-     * @return 是否成功
-     */
     @Override
     public boolean deleteById(String id) {
-        return this.ylxAlarmDao.deleteById(id) > 0;
+        return false;
     }
 
     @Override
     public YlxAlarm addAlarm(YlxAlarm ylxAlarm) {
-        if(StringUtils.isBlank(ylxAlarm.getJsId())){
-            throw new ServiceException("技师ID不能为空");
-        }
-        LambdaQueryWrapper<TOrder> tOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        tOrderLambdaQueryWrapper.eq(TOrder::getcJsId,ylxAlarm.getJsId()).eq(TOrder::getnStatus, OrderStatusEnum.SERVICE.getCode());
-        List<TOrder> orders = orderService.list(tOrderLambdaQueryWrapper);
-
-        if(CollectionUtil.isEmpty(orders)) {
-            throw new ServiceException("没有服务中的订单");
-        }
-        log.info("addAlarm-订单信息：{}", orders);
-        TOrder order = orders.get(0);
-        if(order!=null){
-            LambdaQueryWrapper<YlxAlarm> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.eq(YlxAlarm::getOrderNo,order.getOrderNo());
-            YlxAlarm one = this.getOne(queryWrapper);
-            if(one != null){
-                throw new ServiceException("该订单已报警");
-            }
-            YlxAlarm ylxAlarm1 = new YlxAlarm();
-            TJs js = jsService.getById(order.getcJsId());
-            ylxAlarm1.setJsId(order.getcJsId());
-            ylxAlarm1.setOrderNo(order.getOrderNo());
-            ylxAlarm1.setJsName(js.getcName());
-            ylxAlarm1.setJsPhone(js.getcPhone());
-            ylxAlarm1.setUserName(order.getcName());
-            ylxAlarm1.setUserPhone(order.getcPhone());
-            ylxAlarm1.setAddress(order.getName()+" "+order.getAddress());
-            ylxAlarm1.setOpenId(order.getcOpenId());
-            this.save(ylxAlarm1);
-            return ylxAlarm1;
-        }
-        return ylxAlarm;
+        return null;
     }
 }

nightFragrance-massage/src/main/java/com/ylx/massage/task/massageTask.java

@@ -94,9 +94,9 @@ public class massageTask {
     private Long extracted(Date nowDate) {
         log.info("extracted 开始执行取消订单任务时间,{}", nowDate);
         LambdaQueryWrapper<TOrder> objectLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        objectLambdaQueryWrapper.eq(TOrder::getnStatus, OrderStatusEnum.WAIT_PAY.getCode()).
-                le(TOrder::getDtCreateTime, nowDate).
-                orderByAsc(TOrder::getDtCreateTime);
+        objectLambdaQueryWrapper.eq(TOrder::getStatus, OrderStatusEnum.WAIT_PAY.getCode()).
+                le(TOrder::getCreateTime, nowDate).
+                orderByAsc(TOrder::getCreateTime);
 
         Page<TOrder> page = new Page<>();
         page.setSize(MassageConstants.TWO_HUNDRED);
@@ -106,8 +106,8 @@ public class massageTask {
             resPage.getRecords().forEach(order -> {
                 TOrder newOrder = new TOrder();
                 //todo 订单锁
-                newOrder.setcId(order.getcId());
-                newOrder.setnStatus(OrderStatusEnum.CANCEL.getCode());
+                newOrder.setId(order.getId());
+                newOrder.setStatus(OrderStatusEnum.CANCEL.getCode());
                 orderService.updateById(newOrder);
                 log.info("取消超时未支付订单orderNo,{}", order.getOrderNo());
             });
@@ -130,9 +130,9 @@ public class massageTask {
 
     private Long timeoutNotOrder(Date nowDate) {
         LambdaQueryWrapper<TOrder> objectLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        objectLambdaQueryWrapper.eq(TOrder::getnStatus, OrderStatusEnum.WAIT_JD.getCode()).
-                le(TOrder::getPayTime, nowDate).
-                orderByAsc(TOrder::getPayTime);
+        objectLambdaQueryWrapper.eq(TOrder::getStatus, OrderStatusEnum.WAIT_JD.getCode()).
+                le(TOrder::getPaidTime, nowDate).
+                orderByAsc(TOrder::getPaidTime);
 
         Page<TOrder> page = new Page<>();
         page.setSize(MassageConstants.TWO_HUNDRED);
@@ -141,7 +141,7 @@ public class massageTask {
         if (CollectionUtil.isNotEmpty(resPage.getRecords())) {
             resPage.getRecords().forEach(order -> {
                 //调用拒绝接单
-                order.setReasonRefusal("超时未接单");
+                order.setRejectedReason("超时未接单");
                 orderService.jujue(order);
             });
         }
@@ -253,7 +253,7 @@ public class massageTask {
 
             if (CollectionUtil.isNotEmpty(page1.getRecords())) {
                 page1.getRecords().forEach(tjs -> {
-                    List<TOrder> list = orderService.list(new LambdaQueryWrapper<TOrder>().eq(TOrder::getcJsId, tjs.getId()).ge(TOrder::getDtCreateTime, date));
+                    List<TOrder> list = orderService.list(new LambdaQueryWrapper<TOrder>().eq(TOrder::getMerchantId, tjs.getId()).ge(TOrder::getCreateTime, date));
                     if (CollectionUtil.isEmpty(list) || list.size() < 3) {
                         TJs js = new TJs();
                         js.setId(tjs.getId());

nightFragrance-massage/src/main/java/com/ylx/massage/utils/OrderTimeRangeUtils.java

@@ -24,223 +24,223 @@ public class OrderTimeRangeUtils {
 
     private static final Logger log = LoggerFactory.getLogger(OrderTimeRangeUtils.class);
 
-    /**
-     * 添加缓冲时间（分钟）
-     * <p>
-     * 在两个订单之间添加缓冲时间，用于处理路途、准备等额外时间。
-     * 例如：订单A 14:00结束，订单B 14:30开始，如果有30分钟缓冲时间，则不会冲突。
-     * </p>
-     */
-    private static final int BUFFER_MINUTES = 30;
-
-    /**
-     * 检查新订单是否与现有订单时间范围重叠
-     * <p>
-     * 时间范围重叠判断逻辑：
-     * 1. 如果现有订单或新订单的时间信息不完整，则认为有冲突（保守策略）
-     * 2. 计算两个订单的时间范围，并判断是否重叠
-     * 3. 考虑缓冲时间，在两个订单之间留出缓冲期
-     * </p>
-     *
-     * @param newOrder 新订单
-     * @param existingOrder 现有订单
-     * @return boolean 如果时间范围重叠返回true，否则返回false
-     */
-    public static boolean isTimeRangeOverlapping(TOrder newOrder, TOrder existingOrder) {
-        // 1. 检查现有订单的时间信息
-        LocalDateTime existingStart = existingOrder.getStartTime();
-        LocalDateTime existingEnd = existingOrder.getEndTime();
-
-        // 2. 检查新订单的时间信息
-        LocalDateTime newStart = newOrder.getStartTime();
-        LocalDateTime newEnd = newOrder.getEndTime();
-
-        // 3. 保守策略：如果任何订单的时间信息不完整，认为有冲突
-        if (existingStart == null || existingEnd == null || newStart == null || newEnd == null) {
-            log.warn("订单时间信息不完整，认为时间冲突。现有订单：{}，新订单：{}", existingOrder.getOrderNo(), newOrder.getOrderNo());
-            return true;
-        }
-
-        // 4. 计算新订单的服务时长（分钟）
-        Long newDurationMinutes = calculateOrderDuration(newOrder);
-        if (newDurationMinutes == null || newDurationMinutes <= 0) {
-            log.warn("无法计算新订单的服务时长，订单号：{}", newOrder.getOrderNo());
-            return true;
-        }
-
-        // 5. 重新计算新订单的结束时间（基于当前时间 + 服务时长）
-        LocalDateTime actualNewStart = newStart;
-        LocalDateTime actualNewEnd = actualNewStart.plusMinutes(newDurationMinutes);
-
-        // 6. 应用缓冲时间
-        // 在现有订单结束后增加缓冲时间，新订单需要在缓冲时间之后才能开始
-        //LocalDateTime existingEndWithBuffer = existingEnd.plusMinutes(BUFFER_MINUTES);
-        LocalDateTime existingEndWithBuffer = existingEnd;
-
-        // 7. 判断时间范围是否重叠
-        // 重叠条件：新订单开始时间 < 现有订单结束时间（含缓冲）
-        // 并且：新订单结束时间 > 现有订单开始时间
-        boolean isOverlapping = !actualNewStart.isAfter(existingEndWithBuffer) && !actualNewEnd.isBefore(existingStart);
-
-        if (isOverlapping) {
-            log.info("检测到时间冲突：现有订单 {}（{} - {}）与新订单 {}（{} - {}）",
-                existingOrder.getOrderNo(), existingStart, existingEnd,
-                newOrder.getOrderNo(), actualNewStart, actualNewEnd);
-        } else {
-            log.info("无时间冲突：现有订单 {}（{} - {}）与新订单 {}（{} - {}）",
-                existingOrder.getOrderNo(), existingStart, existingEnd,
-                newOrder.getOrderNo(), actualNewStart, actualNewEnd);
-        }
-        return isOverlapping;
-    }
-
-    /**
-     * 计算订单的服务时长（分钟）
-     * <p>
-     * 从订单明细（cGoods）中获取所有项目的服务时长，并计算总时长。
-     * </p>
-     *
-     * @param order 订单对象
-     * @return Long 服务时长（分钟），如果无法计算则返回null
-     */
-    public static Long calculateOrderDuration(TOrder order) {
-        try {
-            JSONArray goods = order.getcGoods();
-            long totalMinutes = 0;
-
-            for (int i = 0; i < goods.size(); i++) {
-                JSONObject item = goods.getJSONObject(i);
-                Integer minutes = item.getInteger("nMinute");
-                Integer number = item.getInteger("number");
-
-                if (minutes != null && number != null) {
-                    totalMinutes += (minutes * number);
-                }
-            }
-
-            if (totalMinutes <= 0) {
-                log.warn("订单服务时长计算结果无效：{} 分钟，订单号：{}", totalMinutes, order.getOrderNo());
-                return null;
-            }
-
-            log.debug("订单 {} 服务时长：{} 分钟", order.getOrderNo(), totalMinutes);
-            return totalMinutes;
-        } catch (Exception e) {
-            log.error("计算订单服务时长失败，订单号：{}", order.getOrderNo(), e);
-            return null;
-        }
-    }
-
-    /**
-     * 检查订单是否有有效的时间范围
-     * <p>
-     * 判断订单是否具有有效的开始时间和结束时间。
-     * </p>
-     *
-     * @param order 订单对象
-     * @return boolean 如果订单有有效的时间范围返回true，否则返回false
-     */
-    public static boolean hasValidTimeRange(TOrder order) {
-        if (order == null) {
-            return false;
-        }
-
-        LocalDateTime start = order.getStartTime();
-        LocalDateTime end = order.getEndTime();
-
-        return start != null && end != null && start.isBefore(end);
-    }
-
-    /**
-     * 检查是否需要基于服务时长重新计算结束时间
-     * <p>
-     * 对于待接单状态的订单，结束时间可能未设置，需要基于开始时间和服务时长计算。
-     * </p>
-     *
-     * @param order 订单对象
-     * @return boolean 如果需要重新计算结束时间返回true，否则返回false
-     */
-    public static boolean needsEndTimeCalculation(TOrder order) {
-        if (order == null) {
-            return false;
-        }
-
-        // 待接单状态的订单，可能还没有设置结束时间
-        boolean isWaitOrder = OrderStatusEnum.WAIT_JD.getCode().equals(order.getnStatus());
-
-        // 结束时间为空或早于开始时间
-        boolean invalidEndTime = order.getEndTime() == null
-            || (order.getStartTime() != null && order.getEndTime().isBefore(order.getStartTime()));
-
-        return isWaitOrder && invalidEndTime;
-    }
-
-    /**
-     * 订单的开始时间
-     * <p>
-     * 根据订单的当前状态和时间字段，估算订单的开始时间。
-     * - 如果已有startTime，直接使用
-     * - 如果是待接单状态，使用当前时间作为开始时间
-     * - 如果有reachTime，使用到达时间作为开始时间
-     * - 如果有acceptanceTime，使用接单时间+路程时间作为开始时间
-     * </p>
-     *
-     * @param order 订单对象
-     * @return LocalDateTime 估算的开始时间
-     */
-    public static LocalDateTime estimateStartTime(TOrder order) {
-        // 使用已设置的startTime
-        if (order.getStartTime() != null) {
-            return order.getStartTime();
-        }
-        return null;
-    }
-
-    /**
-     * 估算订单的结束时间
-     * <p>
-     * 基于开始时间和订单服务时长，估算订单的结束时间。
-     * </p>
-     *
-     * @param order 订单对象
-     * @return LocalDateTime 估算的结束时间
-     */
-    public static LocalDateTime estimateEndTime(TOrder order) {
-        // 1. 如果已有endTime，直接使用
-        if (order.getEndTime() != null) {
-            return order.getEndTime();
-        }
-
-        // 2. 基于开始时间和服务时长计算
-        LocalDateTime startTime = estimateStartTime(order);
-        if (startTime == null) {
-            return null;
-        }
-
-        Long durationMinutes = calculateOrderDuration(order);
-        log.info("订单 {} 服务时长：{} 分钟", order.getOrderNo(), durationMinutes);
-        if (durationMinutes == null || durationMinutes <= 0) {
-            // 默认60分钟
-            durationMinutes = 60L;
-        }
-        return startTime.plusMinutes(durationMinutes);
-    }
-
-    /**
-     * 检查订单是否是升级订单
-     * <p>
-     * 升级订单（orderType == 2）在原有订单基础上增加服务项目，
-     * 不需要额外的时间互斥校验。
-     * </p>
-     *
-     * @param order 订单对象
-     * @return boolean 如果是升级订单返回true，否则返回false
-     */
-    public static boolean isUpgradeOrder(TOrder order) {
-        return order != null
-            && order.getParentNo() != null
-            && !order.getParentNo().trim().isEmpty()
-            && order.getOrderType() != null
-            && order.getOrderType() == 2;
-    }
+//    /**
+//     * 添加缓冲时间（分钟）
+//     * <p>
+//     * 在两个订单之间添加缓冲时间，用于处理路途、准备等额外时间。
+//     * 例如：订单A 14:00结束，订单B 14:30开始，如果有30分钟缓冲时间，则不会冲突。
+//     * </p>
+//     */
+//    private static final int BUFFER_MINUTES = 30;
+//
+//    /**
+//     * 检查新订单是否与现有订单时间范围重叠
+//     * <p>
+//     * 时间范围重叠判断逻辑：
+//     * 1. 如果现有订单或新订单的时间信息不完整，则认为有冲突（保守策略）
+//     * 2. 计算两个订单的时间范围，并判断是否重叠
+//     * 3. 考虑缓冲时间，在两个订单之间留出缓冲期
+//     * </p>
+//     *
+//     * @param newOrder 新订单
+//     * @param existingOrder 现有订单
+//     * @return boolean 如果时间范围重叠返回true，否则返回false
+//     */
+//    public static boolean isTimeRangeOverlapping(TOrder newOrder, TOrder existingOrder) {
+//        // 1. 检查现有订单的时间信息
+//        LocalDateTime existingStart = existingOrder.getStartTime();
+//        LocalDateTime existingEnd = existingOrder.getEndTime();
+//
+//        // 2. 检查新订单的时间信息
+//        LocalDateTime newStart = newOrder.getStartTime();
+//        LocalDateTime newEnd = newOrder.getEndTime();
+//
+//        // 3. 保守策略：如果任何订单的时间信息不完整，认为有冲突
+//        if (existingStart == null || existingEnd == null || newStart == null || newEnd == null) {
+//            log.warn("订单时间信息不完整，认为时间冲突。现有订单：{}，新订单：{}", existingOrder.getOrderNo(), newOrder.getOrderNo());
+//            return true;
+//        }
+//
+//        // 4. 计算新订单的服务时长（分钟）
+//        Long newDurationMinutes = calculateOrderDuration(newOrder);
+//        if (newDurationMinutes == null || newDurationMinutes <= 0) {
+//            log.warn("无法计算新订单的服务时长，订单号：{}", newOrder.getOrderNo());
+//            return true;
+//        }
+//
+//        // 5. 重新计算新订单的结束时间（基于当前时间 + 服务时长）
+//        LocalDateTime actualNewStart = newStart;
+//        LocalDateTime actualNewEnd = actualNewStart.plusMinutes(newDurationMinutes);
+//
+//        // 6. 应用缓冲时间
+//        // 在现有订单结束后增加缓冲时间，新订单需要在缓冲时间之后才能开始
+//        //LocalDateTime existingEndWithBuffer = existingEnd.plusMinutes(BUFFER_MINUTES);
+//        LocalDateTime existingEndWithBuffer = existingEnd;
+//
+//        // 7. 判断时间范围是否重叠
+//        // 重叠条件：新订单开始时间 < 现有订单结束时间（含缓冲）
+//        // 并且：新订单结束时间 > 现有订单开始时间
+//        boolean isOverlapping = !actualNewStart.isAfter(existingEndWithBuffer) && !actualNewEnd.isBefore(existingStart);
+//
+//        if (isOverlapping) {
+//            log.info("检测到时间冲突：现有订单 {}（{} - {}）与新订单 {}（{} - {}）",
+//                existingOrder.getOrderNo(), existingStart, existingEnd,
+//                newOrder.getOrderNo(), actualNewStart, actualNewEnd);
+//        } else {
+//            log.info("无时间冲突：现有订单 {}（{} - {}）与新订单 {}（{} - {}）",
+//                existingOrder.getOrderNo(), existingStart, existingEnd,
+//                newOrder.getOrderNo(), actualNewStart, actualNewEnd);
+//        }
+//        return isOverlapping;
+//    }
+//
+//    /**
+//     * 计算订单的服务时长（分钟）
+//     * <p>
+//     * 从订单明细（cGoods）中获取所有项目的服务时长，并计算总时长。
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return Long 服务时长（分钟），如果无法计算则返回null
+//     */
+//    public static Long calculateOrderDuration(TOrder order) {
+//        try {
+//            JSONArray goods = order.getcGoods();
+//            long totalMinutes = 0;
+//
+//            for (int i = 0; i < goods.size(); i++) {
+//                JSONObject item = goods.getJSONObject(i);
+//                Integer minutes = item.getInteger("nMinute");
+//                Integer number = item.getInteger("number");
+//
+//                if (minutes != null && number != null) {
+//                    totalMinutes += (minutes * number);
+//                }
+//            }
+//
+//            if (totalMinutes <= 0) {
+//                log.warn("订单服务时长计算结果无效：{} 分钟，订单号：{}", totalMinutes, order.getOrderNo());
+//                return null;
+//            }
+//
+//            log.debug("订单 {} 服务时长：{} 分钟", order.getOrderNo(), totalMinutes);
+//            return totalMinutes;
+//        } catch (Exception e) {
+//            log.error("计算订单服务时长失败，订单号：{}", order.getOrderNo(), e);
+//            return null;
+//        }
+//    }
+//
+//    /**
+//     * 检查订单是否有有效的时间范围
+//     * <p>
+//     * 判断订单是否具有有效的开始时间和结束时间。
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return boolean 如果订单有有效的时间范围返回true，否则返回false
+//     */
+//    public static boolean hasValidTimeRange(TOrder order) {
+//        if (order == null) {
+//            return false;
+//        }
+//
+//        LocalDateTime start = order.getStartTime();
+//        LocalDateTime end = order.getEndTime();
+//
+//        return start != null && end != null && start.isBefore(end);
+//    }
+//
+//    /**
+//     * 检查是否需要基于服务时长重新计算结束时间
+//     * <p>
+//     * 对于待接单状态的订单，结束时间可能未设置，需要基于开始时间和服务时长计算。
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return boolean 如果需要重新计算结束时间返回true，否则返回false
+//     */
+//    public static boolean needsEndTimeCalculation(TOrder order) {
+//        if (order == null) {
+//            return false;
+//        }
+//
+//        // 待接单状态的订单，可能还没有设置结束时间
+//        boolean isWaitOrder = OrderStatusEnum.WAIT_JD.getCode().equals(order.getnStatus());
+//
+//        // 结束时间为空或早于开始时间
+//        boolean invalidEndTime = order.getEndTime() == null
+//            || (order.getStartTime() != null && order.getEndTime().isBefore(order.getStartTime()));
+//
+//        return isWaitOrder && invalidEndTime;
+//    }
+//
+//    /**
+//     * 订单的开始时间
+//     * <p>
+//     * 根据订单的当前状态和时间字段，估算订单的开始时间。
+//     * - 如果已有startTime，直接使用
+//     * - 如果是待接单状态，使用当前时间作为开始时间
+//     * - 如果有reachTime，使用到达时间作为开始时间
+//     * - 如果有acceptanceTime，使用接单时间+路程时间作为开始时间
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return LocalDateTime 估算的开始时间
+//     */
+//    public static LocalDateTime estimateStartTime(TOrder order) {
+//        // 使用已设置的startTime
+//        if (order.getStartTime() != null) {
+//            return order.getStartTime();
+//        }
+//        return null;
+//    }
+//
+//    /**
+//     * 估算订单的结束时间
+//     * <p>
+//     * 基于开始时间和订单服务时长，估算订单的结束时间。
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return LocalDateTime 估算的结束时间
+//     */
+//    public static LocalDateTime estimateEndTime(TOrder order) {
+//        // 1. 如果已有endTime，直接使用
+//        if (order.getEndTime() != null) {
+//            return order.getEndTime();
+//        }
+//
+//        // 2. 基于开始时间和服务时长计算
+//        LocalDateTime startTime = estimateStartTime(order);
+//        if (startTime == null) {
+//            return null;
+//        }
+//
+//        Long durationMinutes = calculateOrderDuration(order);
+//        log.info("订单 {} 服务时长：{} 分钟", order.getOrderNo(), durationMinutes);
+//        if (durationMinutes == null || durationMinutes <= 0) {
+//            // 默认60分钟
+//            durationMinutes = 60L;
+//        }
+//        return startTime.plusMinutes(durationMinutes);
+//    }
+//
+//    /**
+//     * 检查订单是否是升级订单
+//     * <p>
+//     * 升级订单（orderType == 2）在原有订单基础上增加服务项目，
+//     * 不需要额外的时间互斥校验。
+//     * </p>
+//     *
+//     * @param order 订单对象
+//     * @return boolean 如果是升级订单返回true，否则返回false
+//     */
+//    public static boolean isUpgradeOrder(TOrder order) {
+//        return order != null
+//            && order.getParentNo() != null
+//            && !order.getParentNo().trim().isEmpty()
+//            && order.getOrderType() != null
+//            && order.getOrderType() == 2;
+//    }
 }

nightFragrance-massage/src/main/java/com/ylx/order/domain/TOrder.java

@@ -1,24 +1,16 @@
 package com.ylx.order.domain;
 
-import com.alibaba.fastjson.JSONArray;
-import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.baomidou.mybatisplus.annotation.TableName;
-import com.baomidou.mybatisplus.extension.handlers.FastjsonTypeHandler;
-import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.ylx.common.annotation.Excel;
-import com.ylx.massage.domain.TJs;
-import com.ylx.massage.domain.TWxUser;
+import com.ylx.common.core.domain.BaseEntity;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
-import lombok.*;
+import lombok.Data;
 import lombok.experimental.Accessors;
-import java.io.Serializable;
+
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
-import java.util.Date;
 
 /**
  * 订单实体类
@@ -26,7 +18,7 @@ import java.util.Date;
  * 对应数据库表 t_order，用于存储按摩服务订单的完整信息。
  * 包含订单基本信息、服务项目信息、用户信息、技师信息、支付信息、
  * 状态流转信息等多个维度的业务数据。
- *
+ * <p>
  * 订单状态流转：
  * -1(待付款) → 0(待接单) → 1(已接单) → 6(已出发) → 2(已到达) → 3(服务中) → 4(待评价) → 5(已完成)
  * 特殊状态：-2(已取消)、-3(已拒绝)
@@ -36,830 +28,162 @@ import java.util.Date;
  * @version 1.0
  * @since 2023-12-30
  */
-@Getter
-@Setter
+@Data
 @Accessors(chain = true)
 @TableName(value = "t_order", autoResultMap = true)
 @ApiModel(value = "TOrder", description = "订单实体类")
-public class TOrder implements Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * 订单ID
-     * 主键，唯一标识订单记录
-     */
-    @TableId("c_id")
-    @ApiModelProperty("订单ID")
-    private String cId;
-
-    /**
-     * 订单号
-     * 系统生成的唯一订单编号，用于订单查询和标识
-     */
-    @Excel(name = "订单号")
-    @TableField("order_no")
+public class TOrder extends BaseEntity {
+
+    private static final long serialVersionUID = -5178393451245876888L;
+
+    @ApiModelProperty("主键ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
     @ApiModelProperty("订单号")
     private String orderNo;
 
-    /**
-     * 父订单号
-     * 用于升级订单场景，记录原订单号
-     */
-    @TableField("parent_no")
-    @ApiModelProperty("父订单号")
-    private String parentNo;
-
-    /**
-     * 支付类型
-     * 1-微信支付 2-余额支付 3-现金支付
-     */
-    @TableField("pay_type")
-    @ApiModelProperty("支付类型:1微信支付 2:余额支付 3:现金支付")
-    private Integer payType;
-
-    /**
-     * 订单类型
-     * 0-普通订单 1-加钟订单 2-升级订单
-     */
-    @TableField("order_type")
-    @ApiModelProperty("订单类型:0普通订单,1加钟订单,2升级订单")
-    private Integer orderType;
-
-    /**
-     * 是否为虚拟技师订单
-     * 0-否 1-是
-     */
-    @TableField("virtual_order_flag")
-    @ApiModelProperty("是否为虚拟技师订单:0否,1是")
-    private Integer virtualOrderFlag;
-
-    /**
-     * 虚拟技师订单分配情况（0：真实订单 1：未分配 2：已分配）
-     */
-    @TableField("virtual_order_allocation")
-    @ApiModelProperty("虚拟技师订单分配情况（0：真实订单 1：未分配 2：已分配）")
-    private Integer virtualOrderAllocation;
-
-    /**
-     * 技师ID
-     */
-    @TableField("c_js_id")
-    @ApiModelProperty("技师ID")
-    private String cJsId;
-
-    /**
-     * 老技师ID
-     * 用于记录原技师信息，在换技师场景下使用
-     */
-    @TableField("old_js_id")
-    @ApiModelProperty("老技师ID")
-    private String oldJsId;
-
-    /**
-     * 超时原因
-     * 订单超时的原因说明
-     */
-    @TableField("timeout_cause")
-    @ApiModelProperty("超时原因")
-    private String timeoutCause;
-
-    /**
-     * 音频
-     * 订单相关的音频文件路径
-     */
-    @TableField("tape")
-    @ApiModelProperty("音频")
-    private String tape;
-
-    /**
-     * 车费
-     * 根据距离和时段计算的车费金额
-     */
-    @TableField("fare")
-    @ApiModelProperty("车费")
-    private BigDecimal fare;
-
-    /**
-     * 距离
-     * 技师与用户之间的距离，单位：公里
-     */
-    @TableField("distance")
-    @ApiModelProperty("距离")
-    private BigDecimal distance;
-
-
-    /**
-     * 优惠金额
-     * 使用优惠券或其他优惠减免的金额
-     */
-    @TableField("preferential")
-    @ApiModelProperty("优惠金额")
-    private BigDecimal preferential;
-
-    /**
-     * 差价
-     * 升级订单时，需要补交的差价金额
-     */
-    @TableField("price_difference")
-    @ApiModelProperty("差价")
-    private BigDecimal priceDifference;
-
-
-
-    /**
-     * 用户OpenID
-     * 微信用户的唯一标识
-     */
-    @TableField("c_open_id")
-    @ApiModelProperty("用户OpenID")
-    private String cOpenId;
-
-    /**
-     * 经度
-     * 用户地址的经度坐标
-     */
-    @ApiModelProperty("经度")
-    private Double longitude;
-
-    /**
-     * 纬度
-     * 用户地址的纬度坐标
-     */
-    @ApiModelProperty("纬度")
-    private Double latitude;
-
-    /**
-     * 出发经度
-     * 技师出发位置的经度
-     */
-    @ApiModelProperty("出发经度")
-    private BigDecimal departLongitude;
-
-    /**
-     * 出发纬度
-     * 技师出发位置的纬度
-     */
-    @ApiModelProperty("出发纬度")
-    private BigDecimal departLatitude;
-
-    /**
-     * 到达经度
-     * 技师到达用户位置的经度
-     */
-    @ApiModelProperty("到达经度")
-    private BigDecimal arrivalLongitude;
-
-    /**
-     * 到达纬度
-     * 技师到达用户位置的纬度
-     */
-    @ApiModelProperty("到达纬度")
-    private BigDecimal arrivalLatitude;
-
-    /**
-     * 到达照片
-     * 技师到达现场后拍摄的照片URL
-     */
-    @ApiModelProperty("到达照片")
-    private String arrivalPhoto;
+    @ApiModelProperty("用户ID")
+    private Long userId;
 
-    /**
-     * 出发时间
-     * 技师出发前往用户地址的时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("出发时间")
-    private Date departTime;
-
-    /**
-     * 支付时间
-     * 用户完成支付的时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("支付时间")
-    private Date payTime;
-
-    /**
-     * 详细地址
-     * 用户提供的服务地址
-     */
-    @ApiModelProperty("详细地址")
-    private String address;
-
-    /**
-     * 地址名称
-     * 地址的别名或名称标识
-     */
-    @ApiModelProperty("地址名称")
-    private String name;
-
-    /**
-     * 技师的接单时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("接单时间")
-    private LocalDateTime acceptanceTime;
-
-    /**
-     * 到达时间
-     * 技师到达用户地址的时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("到达时间")
-    private LocalDateTime reachTime;
-
-    /**
-     * 开始服务时间
-     * 技师开始提供服务的时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("开始服务时间")
-    private LocalDateTime startTime;
+    @ApiModelProperty("商户ID")
+    private Long merchantId;
 
-    /**
-     * 开始服务时间字符串
-     */
-    @TableField(exist = false)
-    private String startTimeStr;
-
-    /**
-     * 结束时间
-     * 技师完成服务的时间
-     */
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("结束时间")
-    private LocalDateTime endTime;
-
-    @TableField(exist = false)
-    private String endTimeStr;
-
-    /**
-     * 拒接原因
-     * 技师拒绝接单的原因说明
-     */
-    @ApiModelProperty("拒接原因")
-    private String reasonRefusal;
-
-    /**
-     * 领取优惠券ID
-     */
-    @TableField("coupon_receive_id")
-    @ApiModelProperty("领取优惠券ID")
-    private String couponReceiveId;
-
-    /**
-     * 订单明细
-     * JSON格式，包含服务项目的详细信息
-     */
-    @TableField(value = "c_goods", typeHandler = FastjsonTypeHandler.class)
-    @ApiModelProperty("订单明细")
-    private JSONArray cGoods;
-
-    /**
-     * 订单金额
-     * 服务项目的基础金额总和
-     */
-    @TableField("d_total_money")
-    @ApiModelProperty("订单金额")
-    private BigDecimal dTotalMoney;
-
-    /**
-     * 总价
-     * 订单最终金额 = 订单金额 + 车费 - 优惠金额
-     */
-    @Excel(name = "订单金额")
-    @TableField("total_price")
-    @ApiModelProperty("总价")
-    private BigDecimal totalPrice;
-
-    /**
-     * 订单状态
-     * -1-待付款 0-待接单 1-已接单 2-已到达 3-服务中 4-待评价（已完成）
-     * 5-已完成（已评价） 6-已出发 -2-已取消 -3-已拒绝
-     * 7：退单待审核 8：退单审核通过
-     */
-    @TableField("n_status")
-    @ApiModelProperty("订单状态: -1待付款 0待接单 1已接单 6已出发 2已到达 3服务中 4待评价 5已完成 7：退单待审核 8：退单审核通过  -2已取消 -3已拒绝")
-    private Integer nStatus;
-
-    /**
-     * 2026-03-27 新增字段
-     * 订单待结算状态
-     * -0-未结算 1-待结算 2-已结算
-     */
-    @TableField("w_status")
-    @ApiModelProperty("待结算状态: -0-未结算(默认) 1-待结算 2-已结算")
-    private Integer wStatus;
-
-    /**
-     * 备注地址
-     * 地址的补充说明或地标信息
-     */
-    @ApiModelProperty("备注地址")
-    private String atlasAdd;
-
-    /**
-     * 地址
-     * 用户提供的服务地址（冗余字段）
-     */
-    @TableField("c_address")
-    @ApiModelProperty("地址")
-    private String cAddress;
-
-
-    /**
-     * 用户姓名
-     * 下单用户的真实姓名
-     */
-    @Excel(name = "用户姓名")
-    @TableField("c_name")
-    @ApiModelProperty("用户姓名")
-    private String cName;
-
-    /**
-     * 用户电话
-     * 下单用户的联系电话
-     */
-    @Excel(name = "用户电话")
-    @TableField("c_phone")
-    @ApiModelProperty("用户电话")
-    private String cPhone;
-
-    /**
-     * 备注
-     * 用户填写的订单备注信息
-     */
-    @TableField("c_note")
-    @ApiModelProperty("备注")
-    private String cNote;
-
-    /**
-     * 支付截止时间
-     * 订单需要完成支付的截止时间
-     */
-    @TableField("c_time")
-    @ApiModelProperty("支付截止时间")
-    private String cTime;
-
-    /**
-     * 推荐者ID
-     * 推荐用户的OpenID，用于分销统计
-     */
-    @TableField("c_tj_open_id")
-    @ApiModelProperty("推荐者ID")
-    private String cTjOpenId;
-
-    /**
-     * 部门ID
-     * 订单所属的部门/城市标识
-     */
-    @TableField("dept_id")
-    @ApiModelProperty("部门ID")
-    private String deptId;
-
-    /**
-     * 部门名称
-     * 订单所属的城市名称
-     */
-    @TableField("dept_name")
-    @ApiModelProperty("部门名称")
-    private String deptName;
-
-    /**
-     * 创建时间
-     * 订单创建的时间/提交时间
-     */
-    @Excel(name="提交时间")
-    @TableField("dt_create_time")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
-    @ApiModelProperty("创建时间/提交时间")
-    private LocalDateTime dtCreateTime;
-
-    /**
-     * 逻辑删除标记
-     * 0-未删除（有效记录） 1-已删除
-     */
-    @ApiModelProperty("是否删除:0否1是")
-    @TableLogic
-    private Integer isDelete;
+    @ApiModelProperty("商户类型（0：真实商户 1：虚拟商户）")
+    private Integer merchantType;
 
+    @ApiModelProperty("商户昵称")
+    private String merchantNickName;
 
-    /**
-     * 技师信息
-     * 非数据库字段，用于关联查询技师信息
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("技师信息")
-    private TJs js;
-
-    /**
-     * 老技师信息
-     * 非数据库字段，用于关联查询原技师信息
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("老技师信息")
-    private TJs oldJs;
-
-    /**
-     * 剩余支付时间
-     * 非数据库字段，用于计算订单支付的剩余时间（秒）
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("剩余支付时间(秒)")
-    private Long remainingTime;
-
-    /**
-     * 技师姓名
-     * 非数据库字段，用于关联查询技师姓名
-     */
-    @Excel(name = "商户名称")
-    @TableField(exist = false)
-    @ApiModelProperty("技师姓名")
-    private String jsName;
-
-    /**
-     * 技师昵称
-     * 非数据库字段，用于关联查询技师昵称
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("技师昵称")
-    @JsonProperty("cNickName")
-    private String cNickName;
-
-    /**
-     * 技师电话
-     * 非数据库字段，用于关联查询技师电话
-     */
-    @Excel(name = "技师电话")
-    @TableField(exist = false)
-    @ApiModelProperty("技师电话")
-    private String jsPhone;
-
-    /**
-     * 用户信息
-     * 非数据库字段，用于关联查询微信用户信息
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("用户信息")
-    private TWxUser wxUser;
-
-    /**
-     * 订单状态名称
-     * 非数据库字段，用于展示订单状态的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "订单状态名称")
-    @ApiModelProperty("订单状态名称")
-    private String statusName;
-
-    /**
-     * 订单金额
-     * 非数据库字段，用于展示订单金额的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "订单金额")
-    @ApiModelProperty("订单金额")
-    private String orderPrice;
-
-    /**
-     * 实付金额
-     * 非数据库字段，用于展示实付金额的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "实付金额")
-    @ApiModelProperty("实付金额")
-    private String realPayPrice;
-
-    /**
-     * 优惠券补贴
-     * 非数据库字段，用于展示优惠券补贴的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "优惠券补贴")
-    @ApiModelProperty("优惠券补贴")
-    private String couponPrice;
-
-    /**
-     * 平台佣金比例
-     * 非数据库字段，用于展示平台佣金比例的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "平台佣金比例")
-    @ApiModelProperty("平台佣金比例")
-    private String percent;
-
-    /**
-     * 平台佣金
-     * 非数据库字段，用于展示平台佣金的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "平台佣金")
-    @ApiModelProperty("平台佣金")
-    private String yPrice;
-
-    /**
-     * 商户应收金额/待结算金额
-     * 非数据库字段，用于展示商户应收金额的文本描述
-     */
-    @TableField(exist = false)
-    @Excel(name = "商户应收金额")
-    @ApiModelProperty("商户应收金额/待结算金额")
-    private String rPrice;
-
-    /**
-     * 提交时间/订单创建时间
-     * 非数据库字段，用于展示接单时间的文本描述
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("订单创建时间开始")
-    private String dtCreateTimeBegin;
-
-    /**
-     * 订单创建时间
-     * 非数据库字段，用于展示订单创建时间的文本描述
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("订单创建时间结束")
-    private String dtCreateTimeTimeEnd;
-
-    /**
-     * 支付时间
-     * 非数据库字段，用于展示支付时间的文本描述
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("支付时间开始")
-    private String payTimeBegin;
-
-    /**
-     * 支付时间
-     * 非数据库字段，用于展示支付时间的文本描述
-     */
-    @TableField(exist = false)
-    @ApiModelProperty("支付时间结束")
-    private String payTimeEnd;
-
-    /**
-     * 订单服务项目
-     * 非数据库字段，用于展示订单服务项目的文本描述
-     */
-    @Excel(name = "项目名称")
-    @TableField(exist = false)
-    @ApiModelProperty("订单服务项目")
-    private String projectNames;
-
-
-    /**
-     * 服务时长（分钟）
-     */
-    @TableField(exist = false)
-    private String serviceDuration;
-
-    public String getcId() {
-        return cId;
-    }
-
-    public void setcId(String cId) {
-        this.cId = cId;
-    }
-
-    public String getcJsId() {
-        return cJsId;
-    }
-
-    public void setcJsId(String cJsId) {
-        this.cJsId = cJsId;
-    }
-
-    public String getcOpenId() {
-        return cOpenId;
-    }
-
-    public void setcOpenId(String cOpenId) {
-        this.cOpenId = cOpenId;
-    }
-
-    public void setDepartLongitude(BigDecimal departLongitude) {
-        this.departLongitude = departLongitude;
-    }
-
-    public BigDecimal getDepartLongitude() {
-        return departLongitude;
-    }
-
-    public void setArrivalLongitude(BigDecimal arrivalLongitude) {
-        this.arrivalLongitude = arrivalLongitude;
-    }
-
-    public BigDecimal getArrivalLongitude() {
-        return arrivalLongitude;
-    }
-
-    public void setArrivalPhoto(String arrivalPhoto) {
-        this.arrivalPhoto = arrivalPhoto;
-    }
-
-    public String getArrivalPhoto() {
-        return arrivalPhoto;
-    }
-
-    public void setDepartTime(Date departTime) {
-        this.departTime = departTime;
-    }
-
-    public Date getDepartTime() {
-        return departTime;
-    }
-
-    public void setDepartLatitude(BigDecimal departLatitude) {
-        this.departLatitude = departLatitude;
-    }
-
-    public BigDecimal getDepartLatitude() {
-        return departLatitude;
-    }
-
-    public void setArrivalLatitude(BigDecimal arrivalLatitude) {
-        this.arrivalLatitude = arrivalLatitude;
-    }
-
-    public BigDecimal getArrivalLatitude() {
-        return arrivalLatitude;
-    }
-
-    public JSONArray getcGoods() {
-        return cGoods;
-    }
-
-    public void setcGoods(JSONArray cGoods) {
-        this.cGoods = cGoods;
-    }
-
-    public BigDecimal getdTotalMoney() {
-        return dTotalMoney;
-    }
+    @ApiModelProperty("商户头像")
+    private String merchantAvatar;
 
-    public void setdTotalMoney(BigDecimal dTotalMoney) {
-        this.dTotalMoney = dTotalMoney;
-    }
+    @ApiModelProperty("项目ID")
+    private Long projectId;
 
-    public Integer getnStatus() {
-        return nStatus;
-    }
+    @ApiModelProperty("项目类型: MASSAGE, ACCOMPANY")
+    private String projectType; // 对应数据库 enum 类型，Java 中通常用 String 接收，也可自定义枚举类
 
-    public void setnStatus(Integer nStatus) {
-        this.nStatus = nStatus;
-    }
+    @ApiModelProperty("项目名称")
+    private String projectName;
 
-    public String getcAddress() {
-        return cAddress;
-    }
+    @ApiModelProperty("项目封面图")
+    private String projectCover;
 
-    public void setcAddress(String cAddress) {
-        this.cAddress = cAddress;
-    }
+    @ApiModelProperty("预约开始时间")
+    private LocalDateTime appointmentStartTime;
 
-    public String getcName() {
-        return cName;
-    }
+    @ApiModelProperty("项目时长（分钟）")
+    private Integer projectDuration;
 
-    public void setcName(String cName) {
-        this.cName = cName;
-    }
+    @ApiModelProperty("项目亮点")
+    private String highlight;
 
-    public String getcPhone() {
-        return cPhone;
-    }
+    @ApiModelProperty("联系人姓名")
+    private String contactPersonName;
 
-    public void setcPhone(String cPhone) {
-        this.cPhone = cPhone;
-    }
+    @ApiModelProperty("联系人电话号码")
+    private String contactPhoneNumber;
 
-    public String getcNote() {
-        return cNote;
-    }
+    @ApiModelProperty("联系人微信号（可选）")
+    private String contactWechatId;
 
-    public void setcNote(String cNote) {
-        this.cNote = cNote;
-    }
+    @ApiModelProperty("详细服务地址")
+    private String contactAddressInfo;
 
-    public String getcTime() {
-        return cTime;
-    }
+    @ApiModelProperty("项目标价/售价")
+    private BigDecimal basePrice;
 
-    public void setcTime(String cTime) {
-        this.cTime = cTime;
-    }
+    @ApiModelProperty("优惠券抵扣金额")
+    private BigDecimal couponDiscount;
 
-    public String getcTjOpenId() {
-        return cTjOpenId;
-    }
+    @ApiModelProperty("交通费")
+    private BigDecimal trafficFee;
 
-    public void setcTjOpenId(String cTjOpenId) {
-        this.cTjOpenId = cTjOpenId;
-    }
+    @ApiModelProperty("最终应付/实付金额 = base_price - coupon_discoun + traffic_fee")
+    private BigDecimal finalAmount;
 
-    public LocalDateTime getDtCreateTime() {
-        return dtCreateTime;
-    }
+    @ApiModelProperty("付款方式：0=购物卡，1=微信支付")
+    private Integer paymentMethod;
 
-    public void setDtCreateTime(LocalDateTime dtCreateTime) {
-        this.dtCreateTime = dtCreateTime;
-    }
+    @ApiModelProperty("派单时间")
+    private LocalDateTime dispatchedTime;
 
-    public TJs getJs() {
-        return js;
-    }
+    @ApiModelProperty("支付完成时间")
+    private LocalDateTime paidTime;
 
-    public void setJs(TJs js) {
-        this.js = js;
-    }
+    @ApiModelProperty("商户确认/接单时间")
+    private LocalDateTime confirmedTime;
 
-    public TWxUser getWxUser() {
-        return wxUser;
-    }
+    @ApiModelProperty("商户出发时间")
+    private LocalDateTime departedTime;
 
-    public void setWxUser(TWxUser wxUser) {
-        this.wxUser = wxUser;
-    }
+    @ApiModelProperty("商户到达时间")
+    private LocalDateTime arrivedTime;
 
-    public Integer getwStatus() {
-        return wStatus;
-    }
+    @ApiModelProperty("商户签到时间")
+    private LocalDateTime signTime;
 
-    public void setwStatus(Integer wStatus) {
-        this.wStatus = wStatus;
-    }
+    @ApiModelProperty("服务开始时间")
+    private LocalDateTime startTime;
 
-    public String getOrderPrice() {
-        return orderPrice;
-    }
+    @ApiModelProperty("服务完成时间")
+    private LocalDateTime completedTime;
 
-    public void setOrderPrice(String orderPrice) {
-        this.orderPrice = orderPrice;
-    }
+    @ApiModelProperty("订单取消时间")
+    private LocalDateTime cancelledTime;
 
-    public String getRealPayPrice() {
-        return realPayPrice;
-    }
+    @ApiModelProperty("退款时间")
+    private LocalDateTime refundedTime;
 
-    public void setRealPayPrice(String realPayPrice) {
-        this.realPayPrice = realPayPrice;
-    }
+    @ApiModelProperty("发起售后时间")
+    private LocalDateTime afterSalesTime;
 
-    public String getCouponPrice() {
-        return couponPrice;
-    }
+    @ApiModelProperty("拒绝接单时间")
+    private LocalDateTime rejectedTime;
 
-    public void setCouponPrice(String couponPrice) {
-        this.couponPrice = couponPrice;
-    }
+    @ApiModelProperty("删除时间")
+    private LocalDateTime deletedTime;
 
-    public String getPercent() {
-        return percent;
-    }
+    @ApiModelProperty("订单状态：0=待付款，1=待派单，2=待接单，3=待服务，4=服务中，5=售后中，6=已完成，7=已退款，8=已取消，9=已关闭，10=拒绝接单")
+    private Integer status;
 
-    public void setPercent(String percent) {
-        this.percent = percent;
-    }
+    @ApiModelProperty("履约状态：0=待出发/待签到，1=已出发，2=已到达/已签到")
+    private Integer execStatus;
 
-    public String getyPrice() {
-        return yPrice;
-    }
+    @ApiModelProperty("拒接原因")
+    private String rejectedReason;
 
-    public void setyPrice(String yPrice) {
-        this.yPrice = yPrice;
-    }
+    @ApiModelProperty("取消原因")
+    private String cancelledReason;
 
-    public String getrPrice() {
-        return rPrice;
-    }
+    @ApiModelProperty("到达照片")
+    private String arrivalPhoto;
+
+    @ApiModelProperty("开始服务照片")
+    private String startPhoto;
 
-    public void setrPrice(String rPrice) {
-        this.rPrice = rPrice;
-    }
+    @ApiModelProperty("用户下单时纬度")
+    private BigDecimal userLatitude;
 
-    public String getProjectNames() {
-        return projectNames;
-    }
+    @ApiModelProperty("用户下单时经度")
+    private BigDecimal userLongitude;
 
-    public void setProjectNames(String projectNames) {
-        this.projectNames = projectNames;
-    }
+    @ApiModelProperty("商户真实纬度")
+    private BigDecimal merchantLatitude;
 
-    public String getDtCreateTimeBegin() {
-        return dtCreateTimeBegin;
-    }
+    @ApiModelProperty("商户真实经度")
+    private BigDecimal merchantLongitude;
 
-    public void setDtCreateTimeBegin(String dtCreateTimeBegin) {
-        this.dtCreateTimeBegin = dtCreateTimeBegin;
-    }
+    @ApiModelProperty("商户虚拟地址纬度")
+    private BigDecimal virtualLatitude;
 
-    public String getDtCreateTimeTimeEnd() {
-        return dtCreateTimeTimeEnd;
-    }
+    @ApiModelProperty("商户虚拟地址经度")
+    private BigDecimal virtualLongitude;
+
+    @ApiModelProperty("是否删除 0否 1是")
+    private Integer isDelete;
 
-    public void setDtCreateTimeTimeEnd(String dtCreateTimeTimeEnd) {
-        this.dtCreateTimeTimeEnd = dtCreateTimeTimeEnd;
-    }
+    @ApiModelProperty("派单情况：0=未派单 1=已派单")
+    private Integer dispatchedStatus;
 }

nightFragrance-massage/src/main/java/com/ylx/order/service/impl/TOrderServiceImpl.java

@@ -1,39 +1,23 @@
 package com.ylx.order.service.impl;
 
-import cn.hutool.core.collection.CollectionUtil;
-import cn.hutool.json.JSONUtil;
-import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
-import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.ylx.common.config.WechatAccountConfig;
-import com.ylx.common.constant.MassageConstants;
 import com.ylx.common.core.domain.R;
-import com.ylx.common.exception.ServiceException;
-import com.ylx.common.utils.SecurityUtils;
-import com.ylx.massage.domain.*;
-import com.ylx.massage.domain.vo.*;
-import com.ylx.massage.enums.*;
-import com.ylx.order.mapper.TOrderMapper;
-import com.ylx.massage.service.*;
-import com.ylx.massage.utils.*;
+import com.ylx.massage.domain.TWxUser;
+import com.ylx.massage.domain.vo.HomeBlock;
+import com.ylx.massage.domain.vo.OrderVerificationVo;
+import com.ylx.massage.domain.vo.TechnicianAvailabilityVo;
 import com.ylx.order.domain.TOrder;
+import com.ylx.order.mapper.TOrderMapper;
 import com.ylx.order.service.TOrderService;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.compress.utils.Lists;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
-import javax.annotation.Resource;
 import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.time.*;
-import java.util.*;
-import java.util.stream.Collectors;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
 
 
 /**
@@ -43,1613 +27,133 @@ import java.util.stream.Collectors;
 @Slf4j
 public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements TOrderService {
 
-    @Resource
-    private TOrderMapper orderMapper;
-
-    @Resource
-    private WechatAccountConfig wxPayProperties;
-    @Resource
-    private LocationUtil locationUtil;
-
-    @Resource
-    private TWxUserService wxUserService;
-
-    @Resource
-    private TRechargeService rechargeService;
-
-    @Resource
-    private TXiangmuService xiangmuService;
-
-    @Resource
-    private OrderNumberGenerator generator;
-
-    @Resource
-    private TJsService jsService;
-
-    @Resource
-    private TAddressService addressService;
-
-    @Resource
-    private TConsumptionLogService consumptionLogService;
-
-    @Resource
-    private MassageUtil massageUtil;
-
-    @Resource
-    private CouponReceiveService couponReceiveService;
-
-    @Resource
-    private CouponService couponService;
-
-    @Resource
-    private WeChatUtil weChatUtil;
-
-    @Resource
-    private RefundVoucherService refundVoucherService;
-
-    @Resource
-    private OrderValidationService orderValidationService;
-
-    @Resource
-    private OrderNotificationService orderNotificationService;
-
-    @Resource
-    private OrderAllocationLogService allocationLogService;
-
-    @Resource
-    private CancelOrderApplicationService cancelOrderApplicationService;
-
-    @Resource
-    private TTxRecordService recordService;
-
-    @Value("${percent}")
-    private String percent;
-
-    @Value("${hPercent}")
-    private String hPercent;
-
-    /**
-     * 判断是否免车费
-     * 时间段判断：
-     * - 白天时段（7:30-20:00）：距离 ≤ 技师白天免车费里程 → 免费
-     * - 夜间时段（20:00-7:30）：距离 ≤ 技师夜间免车费里程 → 免费
-     *
-     * @param js
-     * @param distance
-     * @return Boolean
-     */
-    public Boolean isFree(TJs js, BigDecimal distance) {
-        Date date = new Date();
-        //白天免车费(07.30-20.00)
-        long current = Long.parseLong(DateTimeUtils.numTime(date));
-        if (current >= MassageConstants.START_FREE && current <= MassageConstants.END_FREE) {
-            if (js.getDaytimeMileage().compareTo(distance) >= 0) {
-                //免车费
-                return Boolean.TRUE;
-            } else {
-                return Boolean.FALSE;
-            }
-        } else {
-            //夜间免车费(20.00-07.30)
-            if (js.getNigthMileage().compareTo(distance) >= 0) {
-                //免车费
-                return Boolean.TRUE;
-            } else {
-                return Boolean.FALSE;
-            }
-        }
-    }
-
-    /**
-     * 添加订单
-     *
-     * @param order
-     * @return TOrder
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public TOrder addOrder(TOrder order) {
-        String jsId = order.getcJsId();
-        // 1. 基础参数校验
-        if (StringUtils.isBlank(jsId)) {
-            throw new ServiceException("请选择技师");
-        }
-        if (order.getcGoods().isEmpty()) {
-            throw new ServiceException("请选择项目");
-        }
-
-        TJs js = jsService.getById(jsId);
-        if (js == null) {
-            throw new ServiceException("技师不存在");
-        }
-        Integer techType = js.getTechType();
-        // 虚拟技师
-        if(techType.equals(1)){
-            //虚拟技师订单
-            order.setVirtualOrderFlag(1);
-            //虚拟技师订单未分配
-            order.setVirtualOrderAllocation(1);
-        }else{
-            //真实订单
-            order.setVirtualOrderFlag(0);
-            order.setVirtualOrderAllocation(0);
-        }
-
-        // 2. 【新增】订单状态锁校验 - 检查技师是否可以接单
-        // 确保技师没有进行中的订单，保证服务时间互斥
-        log.info("开始校验技师 {} 是否可以接单，订单号：{}", order.getcJsId(), order.getOrderNo());
-        orderValidationService.canAcceptOrder(order.getcJsId(), order);
-        log.info("技师 {} 接单校验通过，继续创建订单", order.getcJsId());
-
-        //优惠卷减免
-//        List<CouponReceiveVo> coupons = couponReceiveService.getByOpenId(order.getcOpenId());
-//        BigDecimal preferential = this.setCoupon(coupons);
-//        order.setPreferential(preferential);
-        // 生成订单号
-        order.setOrderNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_ORDER));
-        //订单价格
-        List<TXiangmu> list = JSONObject.parseArray(order.getcGoods().toJSONString(), TXiangmu.class);
-        BigDecimal sum = list.stream().map(TXiangmu::getSum).reduce(BigDecimal.ZERO, BigDecimal::add);
-        //订单总金额
-        order.setdTotalMoney(sum);
-
-        //获取用户默认地址
-        TAddress address = addressService.getByOpenId(order.getcOpenId());
-        if (address == null) {
-            throw new ServiceException("请先添加地址");
-        }
-
-        //添加技师位置信息
-        locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), Double.parseDouble(js.getLongitude().toString()), Double.parseDouble(js.getLatitude().toString()));
-        //添加用户位置信息
-        locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, order.getcOpenId() + order.getOrderNo(), Double.parseDouble(address.getLongitude().toString()), Double.parseDouble(address.getLatitude().toString()));
-        //计算距离
-        double distance = locationUtil.getDistance(js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
-        log.info("技师与用户之间的距离：{}", distance);
-        locationUtil.remove(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
-        order.setDistance(new BigDecimal(distance));
-
-        //计算车费
-        if (order.getDistance() != null && order.getDistance().compareTo(BigDecimal.ZERO) > 0 && StringUtils.isBlank(order.getParentNo())) {
-            //判断是否可以免车费
-            if (!this.isFree(js, order.getDistance())) {
-                BigDecimal bigDecimal = massageUtil.calculateTaxiFare(order.getDistance(), js.getDeptId());
-                order.setFare(bigDecimal.setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP));
-            }
-        }
-        //总价 = 订单 + 车费
-        order.setTotalPrice(sum.add(Optional.ofNullable(order.getFare()).orElse(BigDecimal.ZERO)));
-        if (order.getParentNo() != null && order.getOrderType() == 2) {
-            //升级订单 补差价
-            TOrder partOrder = this.getByNo(order.getParentNo());
-            order.setPriceDifference(order.getTotalPrice().subtract(partOrder.getTotalPrice()));
-        }
-
-        order.setAddress(address.getAddress());
-        order.setName(address.getName());
-        order.setLatitude(address.getLatitude());
-        order.setLongitude(address.getLongitude());
-        order.setcPhone(address.getPhone());
-        //设置用户姓名
-        order.setcName(address.getUserName());
-        order.setAtlasAdd(address.getAtlasAdd());
-        order.setDeptId(js.getDeptId());
-        order.setDeptName(js.getCity());
-        //设置订单状态：待支付
-        order.setnStatus(OrderStatusEnum.WAIT_PAY.getCode());
-        order.setDtCreateTime(LocalDateTime.now());
-        Date date = DateTimeUtils.addMinute(new Date(), 10);
-        order.setcTime(DateTimeUtils.formatDate(date, "yyyy-MM-dd HH:mm:ss"));
-        save(order);
-        return order;
-    }
-
-    private BigDecimal setCoupon(List<CouponReceiveVo> coupons) {
-        //过滤过期的优惠券
-        coupons = coupons.stream().filter(coupon -> coupon.getExpirationTime().after(new Date())).collect(Collectors.toList());
-        //无门槛优惠券
-        /*List<CouponReceiveVo> collect = coupons.stream().filter(coupon -> coupon.getDiscountType().equals(DiscountTypeEnum.NO_THRESHOLD.getCode())).collect(Collectors.toList());*/
-        //支付成功 后 删除优惠卷
-//        couponReceiveService.removeCoupons(collect);
-        //计算优惠金额
-        //return collect.stream().map(CouponReceiveVo::getDiscountValue).reduce(BigDecimal.ZERO, BigDecimal::add);
-        return BigDecimal.ZERO;
-    }
-
-
-    @Override
-    public void payNotifyOrder(String outTradeNo) {
-        //查询未支付的订单
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getOrderNo, outTradeNo).eq(TOrder::getnStatus, OrderStatusEnum.WAIT_PAY.getCode());
-        TOrder orderNew = this.getOne(queryWrapper);
-        if (orderNew == null) {
-            log.error("订单 {} 未支付状态不存在", outTradeNo);
-            return;
-        }
-        // 设置微信支付
-        orderNew.setPayType(1);
-        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
-        orderPayManage(user, orderNew);
+        return null;
     }
 
     @Override
-    public Object updateAddressById(TOrder borrow) {
-        TOrder order = this.getById(borrow.getcId());
-        if (borrow.getLatitude() != null && borrow.getLatitude() != 0 && borrow.getLongitude() != null && borrow.getLongitude() != 0) {
-            order.setAtlasAdd(borrow.getAtlasAdd());
-            order.setcName(borrow.getcName());
-            order.setcPhone(borrow.getcPhone());
-            order.setName(borrow.getName());
-            order.setAddress(borrow.getAddress());
-            order.setLatitude(borrow.getLatitude());
-            order.setLongitude(borrow.getLongitude());
-            TJs js = jsService.getById(order.getcJsId());
-
-            //添加技师位置信息
-            locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), Double.parseDouble(js.getLongitude().toString()), Double.parseDouble(js.getLatitude().toString()));
-            //添加用户位置信息
-            locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, order.getcOpenId() + order.getOrderNo(), Double.parseDouble(borrow.getLongitude().toString()), Double.parseDouble(borrow.getLatitude().toString()));
-            double distance = locationUtil.getDistance(js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
-            locationUtil.remove(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
-            order.setDistance(new BigDecimal(distance));
-            //计算车费
-            if (order.getDistance() != null && order.getDistance().compareTo(BigDecimal.ZERO) > 0) {
-                //判断是否可以免车费
-                if (!this.isFree(js, order.getDistance())) {
-                    BigDecimal bigDecimal = massageUtil.calculateTaxiFare(order.getDistance(), order.getDeptId());
-                    order.setFare(bigDecimal.setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP));
-                }
-            }
-            order.setTotalPrice(order.getdTotalMoney().add(Optional.ofNullable(order.getFare()).orElse(BigDecimal.ZERO)));
-            this.updateById(order);
-        }
-        return order;
+    public R payOrder(TOrder order) throws Exception {
+        return null;
     }
 
     @Override
-    public Object depart(TOrder order) {
-        LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
-        wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.RECEIVED_ORDER.getCode());
-        //设置订单状态：已出发
-        order.setnStatus(OrderStatusEnum.DEPART.getCode());
-        order.setDepartTime(new Date());
-        order.setDepartLongitude(Optional.ofNullable(order.getDepartLongitude()).orElse(BigDecimal.ZERO));
-        order.setDepartLatitude(Optional.ofNullable(order.getDepartLatitude()).orElse(BigDecimal.ZERO));
-        return this.update(order, wrapper);
+    public Boolean jujue(TOrder order) {
+        return null;
     }
 
     @Override
-    public Integer getOrderNum(String jsid, Date startDate, Date endDate) {
-        return orderMapper.getOrderNum(jsid, startDate, endDate);
+    public Boolean confirm(TOrder order) {
+        return null;
     }
 
     @Override
-    public Integer getAddNum(String jsid, Date startDate, Date endDate) {
-        return orderMapper.getAddNum(jsid, startDate, endDate);
+    public Boolean cancle(TOrder order) {
+        return null;
     }
 
     @Override
-    public Integer getUpgradeNum(String jsid, Date startDate, Date endDate) {
-        return orderMapper.getUpgradeNum(jsid, startDate, endDate);
+    public TOrder getByNo(String orderNo) {
+        return null;
     }
 
     @Override
-    public BigDecimal getTurnover(String jsid, Date startDate, Date endDate) {
-        return orderMapper.getTurnover(jsid, startDate, endDate);
+    public Page<TOrder> getAll(Page<TOrder> page, TOrder order) {
+        return null;
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
-    public TOrder transferOrder(TOrder order) {
-        // ========== 第1步：参数校验 ==========
-        if (StringUtils.isBlank(order.getcId())) {
-            throw new ServiceException("订单id不能为空");
-        }
-        if (StringUtils.isBlank(order.getcJsId())) {
-            throw new ServiceException("转单技师ID不能为空");
-        }
-
-        // 定义操作结果（默认为失败）
-        Integer operationResult = 1; // 1-失败
-
-        // 定义操作记录所需的变量
-        String orderId = null;
-        String orderNo = null;
-        String oldTechnicianId = null;
-        String oldTechnicianName = null;
-        Integer oldTechnicianStatusBefore = null;
-        Integer oldTechnicianStatusAfter = null;
-        String newTechnicianId = null;
-        String newTechnicianName = null;
-        Integer newTechnicianStatusBefore = null;
-        Integer newTechnicianStatusAfter = null;
-        Integer orderStatusBefore = null;
-        Integer orderStatusAfter = null;
-        String operatorId = null;
-        String operatorName = null;
-        String operationReason = "虚拟订单分配";
-
-        try {
-            // ========== 第2步：查询原订单信息 ==========
-            TOrder oldOrder = this.getById(order.getcId());
-            if (oldOrder == null) {
-                throw new ServiceException("订单不存在");
-            }
-
-            //原技师ID
-            oldTechnicianId = oldOrder.getcJsId();
-            //新技师ID
-            newTechnicianId = order.getcJsId();
-
-            // 记录订单操作前状态
-            orderStatusBefore = oldOrder.getnStatus();
-            orderId = oldOrder.getcId();
-            orderNo = oldOrder.getOrderNo();
-
-            log.info("开始转单操作 - 订单号：{}, 原技师ID：{}, 新技师ID：{}, 订单状态：{}", oldOrder.getOrderNo(), oldTechnicianId, newTechnicianId, orderStatusBefore);
-
-            // ========== 第3步：查询原技师信息 ==========
-            TJs oldTechnician = jsService.getById(oldTechnicianId);
-            if (oldTechnician == null) {
-                throw new ServiceException("原技师不存在");
-            }
-            oldTechnicianName = oldTechnician.getcName();
-            oldTechnicianStatusBefore = oldTechnician.getnStatus();
-
-            // ========== 第4步：查询新技师信息 ==========
-            TJs newTechnician = jsService.getById(newTechnicianId);
-            if (newTechnician == null) {
-                throw new ServiceException("新技师不存在");
-            }
-            newTechnicianName = newTechnician.getcName();
-            newTechnicianStatusBefore = newTechnician.getnStatus();
-
-            // ========== 第5步：更新订单技师信息 ==========
-            oldOrder.setOldJsId(oldTechnicianId);  // 保存原技师ID
-            oldOrder.setcJsId(newTechnicianId);      // 更新为新技师ID
-
-            log.info("更新订单技师 - 订单号：{}, 原技师：[ID:{}, 姓名:{}], 新技师：[ID:{}, 姓名:{}]", oldOrder.getOrderNo(), oldTechnicianId, oldTechnicianName, newTechnicianId, newTechnicianName);
-
-            if (!this.updateById(oldOrder)) {
-                throw new ServiceException("转单失败：更新订单技师信息失败");
-            }
-
-            // 记录订单操作后状态（转单后状态通常保持不变）
-            orderStatusAfter = oldOrder.getnStatus();
-
-            // ========== 第6步：更新新技师状态（可服务 → 服务中）==========
-            TJs newJsUpdate = new TJs();
-            newJsUpdate.setId(newTechnicianId);
-            newJsUpdate.setnStatus(JsStatusEnum.JS_SERVICE.getCode());
-            if (!jsService.updateById(newJsUpdate)) {
-                throw new ServiceException("转单失败：更新新技师状态失败");
-            }
-            newTechnicianStatusAfter = JsStatusEnum.JS_SERVICE.getCode();
-
-            // ========== 第7步：更新原技师状态（服务中 → 可服务）==========
-            TJs oldJsUpdate = new TJs();
-            oldJsUpdate.setId(oldTechnicianId);
-            oldJsUpdate.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
-            if (!jsService.updateById(oldJsUpdate)) {
-                throw new ServiceException("转单失败：更新原技师状态失败");
-            }
-            oldTechnicianStatusAfter = JsStatusEnum.JS_SERVICEABLE.getCode();
-
-            log.info("更新技师状态完成 - 新技师：{} {}→{}, 原技师：{} {}→{}",
-                newTechnicianName, getStatusName(newTechnicianStatusBefore), getStatusName(newTechnicianStatusAfter),
-                oldTechnicianName, getStatusName(oldTechnicianStatusBefore), getStatusName(oldTechnicianStatusAfter));
-
-            // ========== 第8步：获取操作人信息 ==========
-            operatorId = SecurityUtils.getUserId() != null ? SecurityUtils.getUserId().toString() : "ADMIN";
-            operatorName = SecurityUtils.getUsername() != null ? SecurityUtils.getUsername() : "系统管理员";
-
-            // ========== 第9步：转单成功，设置操作结果为成功 ==========
-            operationResult = 0; // 0-成功
-            log.info("转单操作完成 - 订单号：{}", oldOrder.getOrderNo());
-            return oldOrder;
-        } catch (ServiceException e) {
-            // 业务异常，操作失败
-            log.error("转单操作失败 - 订单号：{}, 错误信息：{}", orderNo, e.getMessage());
-            operationResult = 1; // 1-失败
-            throw e;
-
-        } catch (Exception e) {
-            // 系统异常，操作失败
-            log.error("转单操作异常 - 订单号：{}, 异常信息：{}", orderNo, e.getMessage(), e);
-            operationResult = 1; // 1-失败
-            throw new ServiceException("转单操作异常：" + e.getMessage());
-        } finally {
-            // ========== 第10步：记录转单操作日志（无论成功或失败都记录）==========
-            try {
-                // 只有在获取到基本信息后才记录日志
-                if (orderId != null && orderNo != null && oldTechnicianId != null && newTechnicianId != null) {
-                    allocationLogService.recordTransferOrder(
-                            orderId,                     // orderId
-                            orderNo,                     // orderNo
-                            oldTechnicianId,             // oldTechnicianId
-                            oldTechnicianName,           // oldTechnicianName
-                            oldTechnicianStatusBefore,   // oldTechnicianStatusBefore
-                            oldTechnicianStatusAfter,    // oldTechnicianStatusAfter
-                            newTechnicianId,             // newTechnicianId
-                            newTechnicianName,           // newTechnicianName
-                            newTechnicianStatusBefore,   // newTechnicianStatusBefore
-                            newTechnicianStatusAfter,    // newTechnicianStatusAfter
-                            orderStatusBefore,           // orderStatusBefore
-                            orderStatusAfter,            // orderStatusAfter
-                            operatorId,                  // operatorId
-                            operatorName,                // operatorName
-                            operationReason,             // operationReason
-                            operationResult              // operationResult（0-成功，1-失败）
-                    );
-
-                    String resultDesc = operationResult == 0 ? "成功" : "失败";
-                    log.info("转单操作记录已保存 - 订单号：{}, 操作结果：{}", orderNo, resultDesc);
-                }
-            } catch (Exception e) {
-                // 记录日志失败不影响转单操作
-                log.error("记录转单操作日志失败 - 订单号：{}, 错误信息：{}", orderNo, e.getMessage(), e);
-            }
-        }
-    }
+    public void takingOrders(TOrder order) {
 
-    /**
-     * 获取技师状态名称
-     *
-     * @param status 状态码
-     * @return String 状态名称
-     */
-    private String getStatusName(Integer status) {
-        if (status == null) {
-            return "未知";
-        }
-        switch (status) {
-            case 0:
-                return "可服务";
-            case 1:
-                return "服务中";
-            case 2:
-                return "不可服务";
-            default:
-                return "未知(" + status + ")";
-        }
     }
 
     @Override
-    public List<HomeBlock> getBlock(Date start, Date end, String deptId) {
-        return orderMapper.getBlock(start, end, deptId);
+    public void payNotifyOrder(String outTradeNo) {
 
     }
 
     @Override
-    public OrderVerificationVo verification(TOrder order) {
-        if (StringUtils.isBlank(order.getCouponReceiveId())) {
-            throw new ServiceException("认领优惠券id为空");
-        }
-        if (StringUtils.isBlank(order.getcId())) {
-            throw new ServiceException("订单id为空");
-        }
-        OrderVerificationVo orderVerificationVo = new OrderVerificationVo();
-        TOrder tOrder = this.getById(order.getcId());
-        orderVerificationVo.setCouponReceiveId(order.getCouponReceiveId());
-        CouponReceive couponReceive = couponReceiveService.getById(order.getCouponReceiveId());
-        Coupon coupon = couponService.getById(couponReceive.getCouponId());
-        log.info("订单信息,{}", tOrder);
-        log.info("优惠卷信息,{}", coupon);
-
-
-        //折扣券
-        if (coupon.getDiscountType() == 2) {
-            //判断门槛金额
-            if (tOrder.getTotalPrice().compareTo(coupon.getThresholdAmount()) >= 0) {
-                //折扣值
-                BigDecimal divide = coupon.getRebValue().divide(new BigDecimal(10));
-                //优惠后的金额 = 订单总金额*折扣值
-                BigDecimal bigDecimal = tOrder.getTotalPrice().multiply(divide).setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP);
-                //优惠值
-                orderVerificationVo.setPreferential(tOrder.getTotalPrice().subtract(bigDecimal));
-                orderVerificationVo.setTotalPrice(bigDecimal);
-            } else {
-                throw new ServiceException("不满足优惠券门槛金额");
-            }
-        } else {
-            if (tOrder.getTotalPrice().compareTo(coupon.getThresholdAmount()) >= 0) {
-                //优惠值
-                orderVerificationVo.setPreferential(coupon.getDiscountValue());
-                orderVerificationVo.setTotalPrice(tOrder.getTotalPrice().subtract(coupon.getDiscountValue()));
-            } else {
-                throw new ServiceException("不满足优惠券门槛金额");
-            }
-        }
-        if (orderVerificationVo.getTotalPrice().compareTo(BigDecimal.ZERO) < 0) {
-            throw new ServiceException("当前项目不可用");
-        }
-        return orderVerificationVo;
-    }
-
-    private TOrder getOrder(TOrder tOrder) {
-        if (updateById(tOrder)) {
-            return tOrder;
-        } else {
-            throw new ServiceException("优惠券核销失败");
-        }
+    public Object updateAddressById(TOrder borrow) {
+        return null;
     }
 
-
-    /**
-     * 支付订单
-     *
-     * @param order
-     * @return R
-     */
     @Override
-    public R payOrder(TOrder order) throws Exception {
-        // 根据订单ID查询订单信息
-        TOrder orderNew = getById(order.getcId());
-        if (!orderNew.getnStatus().equals(OrderStatusEnum.WAIT_PAY.getCode())) {
-            throw new ServiceException("该订单已经支付或者超时被取消");
-        }
-        TJs js = jsService.getById(orderNew.getcJsId());
-        if (StringUtils.isBlank(orderNew.getParentNo())) {
-            if (null == js || js.getnStatus().equals(JsStatusEnum.JS_SERVICE.getCode())) {
-                throw new ServiceException("该技师已在服务中请重新下单");
-            }
-        }
-
-        orderNew.setPayType(order.getPayType());
-        //优惠券核销
-        if (StringUtils.isNotBlank(order.getCouponReceiveId())) {
-            orderNew.setCouponReceiveId(order.getCouponReceiveId());
-            orderNew.setPreferential(order.getPreferential());
-            orderNew.setTotalPrice(order.getTotalPrice());
-            if (!updateById(orderNew)) {
-                throw new ServiceException("支付失败");
-            }
-        }
-        //判断支付方式
-        if (order.getPayType().equals(MassageConstants.INTEGER_ONE)) {
-            //微信支付
-            R resp = rechargeService.getPay(orderNew.getOrderNo(), orderNew.getTotalPrice(), orderNew.getcOpenId(), BillTypeEnum.WX_PAY.getInfo(), BillTypeEnum.WX_PAY.getCode().toString());
-
-            //添加待接单消息通知（技师侧）这块的逻辑在回调接口中
-            //orderNotificationService.sendPendingRemindNotification(orderNew);
-            return resp;
-        }
-
-        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
-        if (null == user) {
-            throw new ServiceException("用户不存在");
-        }
-        //现金支付
-        if (order.getPayType().equals(MassageConstants.INTEGER_THREE)) {
-            //现金支付
-            orderPayManage(user, orderNew);
-            //添加待接单消息通知（技师侧）
-            orderNotificationService.sendPendingRemindNotification(orderNew);
-            return R.ok();
-        }
-        if (user.getdBalance().compareTo(orderNew.getTotalPrice()) < MassageConstants.INTEGER_ZERO) {
-            throw new ServiceException("账户金额不够请充值");
-        } else {
-            orderPayManage(user, orderNew);
-            //添加待接单消息通知（技师侧）
-            orderNotificationService.sendPendingRemindNotification(orderNew);
-            return R.ok();
-        }
-    }
-
-
-
-    /**
-     * 新订单通知
-     *
-     * @param order
-     */
-    public void newOrderNotification(TOrder order) {
-        cn.hutool.json.JSONObject param = JSONUtil.createObj();
-        //订单号
-        param.set("character_string9", JSONUtil.createObj().set("value", order.getOrderNo()));
-        //电话
-        param.set("phone_number14", JSONUtil.createObj().set("value", order.getcPhone()));
-        param.set("thing18", JSONUtil.createObj().set("value", order.getcName()));
-        param.set("time6", JSONUtil.createObj().set("value", DateTimeUtils.formatDate(new Date(), DateTimeUtils.DATE_NUMBER_YEAR_MONTH_FORMAT)));
-        param.set("thing27", JSONUtil.createObj().set("value", order.getName()));
-        TJs js = jsService.getById(order.getcJsId());
-        weChatUtil.notification(js.getcOpenId(), wxPayProperties.getTemplateId1(), param);
-
-    }
-
-    /**
-     * 订单支付管理
-     *
-     * @param user
-     * @param orderNew
-     */
-    @Transactional(rollbackFor = Exception.class)
-    public void orderPayManage(TWxUser user, TOrder orderNew) {
-        //更新优惠卷状态
-        if (StringUtils.isNotBlank(orderNew.getCouponReceiveId())) {
-            CouponReceive couponReceive = new CouponReceive();
-            couponReceive.setId(orderNew.getCouponReceiveId());
-            couponReceive.setCouponStatus(MassageConstants.INTEGER_TWO);
-            if (!couponReceiveService.updateById(couponReceive)) {
-                log.error("优惠券状态更新失败id:,{}", orderNew.getCouponReceiveId());
-            }
-        }
-
-        // 更新用户金额 及下单此时
-        TWxUser paramUser = new TWxUser();
-        paramUser.setcOpenid(user.getcOpenid());
-        // 余额支付
-        if (orderNew.getPayType().equals(MassageConstants.INTEGER_TWO)) {
-            paramUser.setdBalance(user.getdBalance().subtract(orderNew.getTotalPrice()));
-        }
-        paramUser.setdMoney(user.getdMoney().add(orderNew.getTotalPrice()));
-        paramUser.setnNum(user.getnNum() + MassageConstants.INTEGER_ONE);
-        paramUser.setId(user.getId());
-        wxUserService.updateById(paramUser);
-        //增加消费记录
-        TConsumptionLog tConsumptionLog = new TConsumptionLog();
-        tConsumptionLog.setAmount(orderNew.getTotalPrice().negate());
-        tConsumptionLog.setBillNo(orderNew.getOrderNo());
-        tConsumptionLog.setOpenId(orderNew.getcOpenId());
-        if (orderNew.getPayType().equals(MassageConstants.INTEGER_TWO)) {
-            tConsumptionLog.setBillType(BillTypeEnum.BALANCE_PAYMENT.getCode());
-            tConsumptionLog.setNote("余额支付");
-        } else if(orderNew.getPayType().equals(MassageConstants.INTEGER_ONE)){
-            tConsumptionLog.setBillType(BillTypeEnum.WX_PAY.getCode());
-            tConsumptionLog.setNote("微信支付");
-        } else {
-            tConsumptionLog.setBillType(BillTypeEnum.CASH_PAYMENT.getCode());
-            tConsumptionLog.setNote("现金支付");
-        }
-
-        consumptionLogService.save(tConsumptionLog);
-        // 更新项目数据
-        JSONArray objects = orderNew.getcGoods();
-        objects.forEach(item -> {
-            UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
-            // 获取参数
-            wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
-            // 设置数量
-            wrapper.setSql(" n_sale_number = n_sale_number + " + ((JSONObject) item).getInteger("number"));
-            xiangmuService.update(wrapper);
-        });
-        TOrder orderParam = new TOrder();
-        orderParam.setPayType(orderNew.getPayType());
-        orderParam.setcId(orderNew.getcId());
-        orderParam.setnStatus(OrderStatusEnum.WAIT_JD.getCode());
-        orderParam.setPayTime(new Date());
-        //加钟的订单支付完直接服务中
-        if (StringUtils.isNotBlank(orderNew.getParentNo())) {
-            orderParam.setnStatus(OrderStatusEnum.SERVICE.getCode());
-        }
-//            orderParam.setnStatus(OrderStatusEnum.SERVICE.getCode());
-        //更新及技师状态
-        updateJs(orderNew);
-        updateById(orderParam);
-        //
-        //this.newOrderNotification(orderNew);
-
-        //添加待接单消息通知（技师侧）
-        orderNotificationService.sendPendingRemindNotification(orderNew);
-        //电话通知
-        TJs js = jsService.getById(orderNew.getcJsId());
-        Sendvoice.sendPhone(js.getcPhone());
+    public Object depart(TOrder order) {
+        return null;
     }
 
-    /**
-     * 拒绝订单
-     *
-     * @param order
-     */
     @Override
-    public Boolean jujue(TOrder order) {
-
-        TOrder orderNew = getById(order.getcId());
-
-        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
-        // 更新用户金额 及下单此时
-        TWxUser paramUser = new TWxUser();
-        paramUser.setcOpenid(user.getcOpenid());
-        paramUser.setId(user.getId());
-        // 余额记录
-        TConsumptionLog tConsumptionLog = new TConsumptionLog();
-        tConsumptionLog.setAmount(orderNew.getTotalPrice());
-        tConsumptionLog.setBillNo(orderNew.getOrderNo());
-        tConsumptionLog.setOpenId(orderNew.getcOpenId());
-        if (orderNew.getPayType() == 2) {
-            // 金额归还对应账户
-            paramUser.setdBalance(user.getdBalance().add(orderNew.getTotalPrice()));
-            tConsumptionLog.setBillType(BillTypeEnum.REFUSE_ACCEPT_REFUND.getCode());
-            tConsumptionLog.setNote("拒绝接单退款到余额");
-
-        } else {
-            // 微信支付
-            // 生成退款单退款
-            RefundVoucher refundVoucher = new RefundVoucher();
-            refundVoucher.setRefundNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_REFUND));
-            refundVoucher.setOrderNo(orderNew.getOrderNo());
-            refundVoucher.setMoney(orderNew.getTotalPrice());
-            refundVoucher.setOpenId(orderNew.getcOpenId());
-            refundVoucher.setReStatus(MassageConstants.INTEGER_ZERO);
-            refundVoucher.setReason("技师拒绝接单");
-            refundVoucherService.save(refundVoucher);
-            tConsumptionLog.setBillType(BillTypeEnum.REFUSE_ACCEPT_REFUND.getCode());
-            tConsumptionLog.setNote("拒绝接单退款到余额");
-            // 微信退款原路返回
-            rechargeService.refund(refundVoucher.getRefundNo(), null, orderNew.getOrderNo(), orderNew.getTotalPrice());
-        }
-        consumptionLogService.save(tConsumptionLog);
-        //退优惠卷
-        if (StringUtils.isNotBlank(orderNew.getCouponReceiveId())) {
-            CouponReceive couponReceive = couponReceiveService.getById(orderNew.getCouponReceiveId());
-            couponReceive.setCouponStatus(MassageConstants.INTEGER_ZERO);
-            couponReceiveService.updateById(couponReceive);
-        }
-        log.info("余额支付退款user:{}", user);
-
-        // 消费金额对应减少
-        paramUser.setdMoney(user.getdMoney().subtract(orderNew.getTotalPrice()));
-        // 下单次数减一
-        paramUser.setnNum(user.getnNum() - MassageConstants.INTEGER_ONE);
-        wxUserService.updateById(paramUser);
-
-        // 更新项目数据
-        JSONArray objects = orderNew.getcGoods();
-        objects.forEach(item -> {
-            UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
-            // 获取参数
-            wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
-            // 设置数量
-            wrapper.setSql(" n_sale_number = n_sale_number - " + ((JSONObject) item).getInteger("number"));
-            xiangmuService.update(wrapper);
-        });
-        TOrder orderParam = new TOrder();
-        orderParam.setcId(orderNew.getcId());
-        orderParam.setnStatus(OrderStatusEnum.REFUSE.getCode());
-        orderParam.setReasonRefusal(order.getReasonRefusal());
-
-        // 订单结算状态:未结算  2026-03-27 lixl
-        orderParam.setwStatus(OrderWStateEnum.NO_ACCOUNT.getCode());
-        updateJs(orderNew);
-        return updateById(orderParam);
+    public Integer getOrderNum(String jsid, Date startDate, Date endDate) {
+        return 0;
     }
 
-    /**
-     * 确认服务完成
-     *
-     * @param order
-     * @return Boolean
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
-    public Boolean confirm(TOrder order) {
-        // 获取订单信息
-        TOrder orderNew = getById(order.getcId());
-        if (!orderNew.getnStatus().equals(OrderStatusEnum.SERVICE.getCode())) {
-            throw new ServiceException("订单状态不是服务中");
-        }
-        // 更新技师信息
-        TJs jsParam = new TJs();
-        jsParam.setId(orderNew.getcJsId());
-        jsParam.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
-        //判断热度标识
-        List<TOrder> list = list(new LambdaQueryWrapper<TOrder>().eq(TOrder::getcJsId, orderNew.getcJsId())
-                .ge(TOrder::getDtCreateTime, DateTimeUtils.addDays(new Date(), -3))
-                .ge(TOrder::getnStatus, OrderStatusEnum.WAIT_EVALUATE.getCode()));
-        if (list.size() >= 2) {
-            // 设置热度标识：1
-            jsParam.setnB3(MassageConstants.INTEGER_ONE);
-        }
-        // 更新技师状态
-        jsService.updateById(jsParam);
-        // 更新技师钱包金额
-        TJs jsById = jsService.getById(orderNew.getcJsId());
-        // 获取技师抽成
-        BigDecimal multiply = orderNew.getTotalPrice().multiply(new BigDecimal(jsById.getnBili()));
-        multiply = multiply.divide(new BigDecimal(100), MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP);
-        // 获取技师所对应的用户
-        TWxUser jsUser = wxUserService.getByOpenId(jsById.getcOpenId());
-        // 更新余额
-        jsUser.setdBalance(jsUser.getdBalance().add(multiply));
-        // 更新总钱数
-        jsUser.setdAllMoney(jsUser.getdAllMoney().add(multiply));
-        wxUserService.updateById(jsUser);
-
-        //增加消费记录
-        TConsumptionLog tConsumptionLog = new TConsumptionLog();
-        tConsumptionLog.setAmount(multiply);
-        tConsumptionLog.setBillNo(orderNew.getOrderNo());
-        tConsumptionLog.setOpenId(jsUser.getcOpenid());
-        tConsumptionLog.setBillType(BillTypeEnum.INCOME.getCode());
-        tConsumptionLog.setNote("技师收益");
-        consumptionLogService.save(tConsumptionLog);
-
-        // 如果该技师有推荐人员 一级
-        if (StringUtils.isNotBlank(jsUser.getcUpUser())) {
-            // 获取技师上级对应的用户
-            TWxUser jsUp = wxUserService.getByOpenId(jsUser.getcUpUser());
-            extracted(orderNew, jsUp);
-            //二级
-            if (StringUtils.isNotBlank(jsUp.getcUpUser())) {
-                TWxUser jsUpTwo = wxUserService.getByOpenId(jsUp.getcUpUser());
-                extracted(orderNew, jsUpTwo);
-                //三级
-                if (StringUtils.isNotBlank(jsUpTwo.getcUpUser())) {
-                    TWxUser jsUpThree = wxUserService.getByOpenId(jsUpTwo.getcUpUser());
-                    extracted(orderNew, jsUpThree);
-                }
-            }
-        }
-        // 更新订单
-        // 订单状态：待评价
-        orderNew.setnStatus(OrderStatusEnum.WAIT_EVALUATE.getCode());
-        orderNew.setEndTime(LocalDateTime.now());
-
-        // 订单结算状态:待结算  2026-03-27 lixl
-        orderNew.setwStatus(OrderWStateEnum.WAIT_ACCOUNT.getCode());
-        updateById(orderNew);
-
-        // 添加订单完成消息通知（用户侧）
-        orderNotificationService.sendCompletedNotification(orderNew);
-        return true;
-    }
-
-    private void extracted(TOrder orderNew, TWxUser jsUp) {
-        log.info("TOrderServiceImpl->extracted->jsUp,{}", JSONUtil.toJsonStr(jsUp));
-        log.info("TOrderServiceImpl->extracted->orderNew,{}",JSONUtil.toJsonStr(orderNew));
-        BigDecimal up = orderNew.getdTotalMoney().multiply(new BigDecimal("10"));
-        up = up.divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
-        // 更新余额
-        jsUp.setdBalance(jsUp.getdBalance().add(up));
-        // 更新总钱数
-        jsUp.setdAllMoney(jsUp.getdAllMoney().add(up));
-        jsUp.setDistributionAmount(up);
-        wxUserService.updateById(jsUp);
-
-        //记录分销收益
-        TConsumptionLog tConsumptionLog = new TConsumptionLog();
-        tConsumptionLog.setAmount(up);
-        tConsumptionLog.setBillNo(orderNew.getOrderNo());
-        tConsumptionLog.setOpenId(jsUp.getcOpenid());
-        tConsumptionLog.setBillType(BillTypeEnum.DISTRIBUTION.getCode());
-        tConsumptionLog.setNote("分销收益");
-        consumptionLogService.save(tConsumptionLog);
+    public Integer getAddNum(String jsid, Date startDate, Date endDate) {
+        return 0;
     }
 
-    /**
-     * 获取技师当天可预约时间
-     *
-     * @param technicianId 技师ID
-     * @param dateStr 查询日期（格式：yyyy-MM-dd），为null则查询当天
-     * @return TechnicianAvailabilityVo 技师当天可预约时间VO
-     */
     @Override
-    public TechnicianAvailabilityVo getTechnicianAvailability(String technicianId, String dateStr) {
-        // 1. 参数校验
-        if (StringUtils.isBlank(technicianId)) {
-            throw new ServiceException("技师ID不能为空");
-        }
-
-        // 2. 查询技师信息
-        TJs js = jsService.getById(technicianId);
-        if (js == null) {
-            throw new ServiceException("技师不存在");
-        }
-
-        // 3. 解析日期，默认为当天
-        LocalDate queryDate;
-        if (StringUtils.isBlank(dateStr)) {
-            queryDate = LocalDate.now();
-        } else {
-            try {
-                queryDate = LocalDate.parse(dateStr);
-            } catch (Exception e) {
-                throw new ServiceException("日期格式错误，请使用 yyyy-MM-dd 格式");
-            }
-        }
-
-        // 4. 定义当天的所有时间段（以30分钟为间隔，从00:00到23:30）
-        List<TimeSlotVo> timeSlots = new ArrayList<>();
-        for (int hour = 0; hour < 24; hour++) {
-            // 每小时生成两个时间段：xx:00 和 xx:30
-            timeSlots.add(TimeSlotVo.builder()
-                    .time(String.format("%02d:00", hour))
-                    .available(true)
-                    .build());
-            timeSlots.add(TimeSlotVo.builder()
-                    .time(String.format("%02d:30", hour))
-                    .available(true)
-                    .build());
-        }
-
-        // 5. 查询技师当天所有进行中的订单
-        // 开始时间
-        LocalDateTime startOfDay = queryDate.atStartOfDay();
-        // 结束时间
-        LocalDateTime endOfDay = queryDate.plusDays(1).atStartOfDay();
-        log.info("开始时间：{}，结束时间：{}", startOfDay, endOfDay);
-
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getcJsId, technicianId)
-                .in(TOrder::getnStatus, OrderStatusEnum.WAIT_JD.getCode(),
-                        OrderStatusEnum.RECEIVED_ORDER.getCode(),
-                        OrderStatusEnum.DEPART.getCode(),
-                        OrderStatusEnum.ARRIVED.getCode(),
-                        OrderStatusEnum.SERVICE.getCode())
-                .ge(TOrder::getDtCreateTime, startOfDay)
-                .lt(TOrder::getDtCreateTime, endOfDay)
-                .eq(TOrder::getIsDelete, 0);
-
-        List<TOrder> orders = this.list(queryWrapper);
-        log.info("技师{}，在{}天共有 {} 个进行中的订单", technicianId, queryDate, orders.size());
-
-        // 6. 标记不可预约的时间段
-        LocalDateTime now = LocalDateTime.now();
-        for (TOrder order : orders) {
-            // 6.1 计算订单的开始时间和结束时间
-            LocalDateTime orderStart = OrderTimeRangeUtils.estimateStartTime(order);
-            LocalDateTime orderEnd = OrderTimeRangeUtils.estimateEndTime(order);
-
-            if (orderStart == null || orderEnd == null) {
-                log.warn("订单 {} 的时间信息不完整，跳过", order.getOrderNo());
-                continue;
-            }
-
-            // 6.2 限制在查询日期范围内
-            LocalDateTime effectiveStart = orderStart.isBefore(startOfDay) ? startOfDay : orderStart;
-            LocalDateTime effectiveEnd = orderEnd.isAfter(endOfDay) ? endOfDay : orderEnd;
-            // 6.3 标记不可预约的时间段
-            markTimeSlotsUnavailable(timeSlots, effectiveStart, effectiveEnd, order.getOrderNo());
-        }
-
-        // 7. 根据查询日期判断是否可预约
-        LocalDate today = LocalDate.now();
-        if (queryDate.isBefore(today)) {
-            // 查询日期是过去的日期，所有时间段都不可预约
-            markAllTimeSlotsUnavailable(timeSlots, "日期已过期");
-        } else if (queryDate.equals(today)) {
-            // 查询日期是今天，标记过去的时间为不可预约
-            markPastTimeSlotsUnavailable(timeSlots, now);
-        }
-        // 查询日期是未来的日期，所有时间段默认可预约，无需处理
-        // 8. 构建返回结果
-        return TechnicianAvailabilityVo.builder()
-                .date(queryDate.toString())
-                .technicianId(technicianId)
-                .technicianName(js.getcName())
-                .timeSlots(timeSlots)
-                .build();
-    }
-
-    /**
-     * 标记指定时间范围内的时间段为不可预约
-     *
-     * @param timeSlots 时间段列表
-     * @param start 开始时间
-     * @param end 结束时间
-     * @param orderNo 订单号
-     */
-    private void markTimeSlotsUnavailable(List<TimeSlotVo> timeSlots, LocalDateTime start, LocalDateTime end, String orderNo) {
-        LocalTime startTime = start.toLocalTime();
-        LocalTime endTime = end.toLocalTime();
-
-        for (TimeSlotVo slot : timeSlots) {
-            LocalTime slotTime = LocalTime.parse(slot.getTime());
-
-            // 判断时间段是否在订单时间范围内
-            boolean isInRange = !slotTime.isBefore(startTime) && slotTime.isBefore(endTime);
-            if (isInRange) {
-                slot.setAvailable(false);
-                slot.setReason("已有订单");
-                slot.setOrderNo(orderNo);
-            }
-        }
+    public Integer getUpgradeNum(String id, Date startDate, Date endDate) {
+        return 0;
     }
 
-    /**
-     * 标记所有时间段为不可预约
-     *
-     * @param timeSlots 时间段列表
-     * @param reason 不可预约原因
-     */
-    private void markAllTimeSlotsUnavailable(List<TimeSlotVo> timeSlots, String reason) {
-        for (TimeSlotVo slot : timeSlots) {
-            slot.setAvailable(false);
-            slot.setReason(reason);
-            slot.setOrderNo(null);
-        }
-    }
-
-    /**
-     * 标记过去的时间段为不可预约
-     *
-     * @param timeSlots 时间段列表
-     * @param now 当前时间
-     */
-    private void markPastTimeSlotsUnavailable(List<TimeSlotVo> timeSlots, LocalDateTime now) {
-        LocalTime currentTime = now.toLocalTime();
-        for (TimeSlotVo slot : timeSlots) {
-            LocalTime slotTime = LocalTime.parse(slot.getTime());
-
-            // 如果当前时间已经过了这个时间段，标记为不可预约
-            if (slotTime.isBefore(currentTime)) {
-                slot.setAvailable(false);
-                slot.setReason("已过期");
-                slot.setOrderNo(null);
-            }
-        }
-    }
-
-    /**
-     * 取消订单
-     *
-     * @param order
-     * @return Boolean
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
-    public Boolean cancle(TOrder order) {
-        // 获取订单信息
-        // 根据orderid查询订单信息
-        TOrder orderNew = getById(order.getcId());
-        //待接单
-        if (Objects.equals(orderNew.getnStatus(), OrderStatusEnum.WAIT_JD.getCode())) {
-            TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
-            // 更新用户金额 及下单此时
-            TWxUser paramUser = new TWxUser();
-            paramUser.setId(user.getId());
-            paramUser.setcOpenid(user.getcOpenid());
-
-            TConsumptionLog tConsumptionLog = new TConsumptionLog();
-            tConsumptionLog.setAmount(orderNew.getTotalPrice());
-            tConsumptionLog.setBillNo(orderNew.getOrderNo());
-            tConsumptionLog.setOpenId(orderNew.getcOpenId());
-            // 余额支付
-            if (orderNew.getPayType() == 2) {
-                // 金额归还对应账户
-                paramUser.setdBalance(user.getdBalance().add(orderNew.getTotalPrice()));
-                // 余额记录
-                tConsumptionLog.setBillType(BillTypeEnum.CANCEL_ACCEPT_REFUND.getCode());
-                tConsumptionLog.setNote("取消订单退款到余额");
-                //自己取消的不退优惠卷
-            } else {
-                // 微信支付
-                // 生成退款单退款
-                RefundVoucher refundVoucher = new RefundVoucher();
-                refundVoucher.setRefundNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_REFUND));
-                refundVoucher.setOrderNo(orderNew.getOrderNo());
-                refundVoucher.setMoney(orderNew.getTotalPrice());
-                refundVoucher.setOpenId(orderNew.getcOpenId());
-                refundVoucher.setReStatus(MassageConstants.INTEGER_ZERO);
-                refundVoucher.setReason("技师拒绝接单");
-                refundVoucherService.save(refundVoucher);
-                tConsumptionLog.setBillType(BillTypeEnum.CANCEL_WX_REFUND.getCode());
-                tConsumptionLog.setNote("取消订单退款到微信");
-                // 微信退款原路返回
-                rechargeService.refund(refundVoucher.getRefundNo(), null, orderNew.getOrderNo(), orderNew.getTotalPrice());
-            }
-            consumptionLogService.save(tConsumptionLog);
-            // 消费金额对应减少
-            paramUser.setdMoney(user.getdMoney().subtract(orderNew.getTotalPrice()));
-            // 下单次数减一
-            paramUser.setnNum(user.getnNum() - MassageConstants.INTEGER_ONE);
-            wxUserService.updateById(paramUser);
-
-            // 更新项目数据
-            JSONArray objects = orderNew.getcGoods();
-            objects.forEach(item -> {
-                UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
-                // 获取参数
-                wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
-                // 设置数量
-                wrapper.setSql(" n_sale_number = n_sale_number - " + ((JSONObject) item).getInteger("number"));
-                xiangmuService.update(wrapper);
-            });
-            TOrder orderParam = new TOrder();
-            orderParam.setcId(orderNew.getcId());
-            orderParam.setnStatus(OrderStatusEnum.CANCEL.getCode());
-
-            // 订单结算状态:未结算  2026-03-27 lixl
-            orderParam.setwStatus(OrderWStateEnum.NO_ACCOUNT.getCode());
-
-            //更新技师状态
-            TJs tJs = new TJs();
-            tJs.setId(orderNew.getcJsId());
-            tJs.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
-            jsService.updateById(tJs);
-            updateById(orderParam);
-
-            // 添加取消订单通知（用户侧）
-            orderNotificationService.sendCancelledNotification(orderNew);
-
-            // 添加取消订单通知（技师侧）
-            orderNotificationService.sendTechnicianCancelledNotification(orderNew);
-            return true;
-        } else if (Objects.equals(orderNew.getnStatus(), OrderStatusEnum.WAIT_PAY.getCode())) {//待付款
-            TOrder orderParam = new TOrder();
-            orderParam.setcId(orderNew.getcId());
-            orderParam.setnStatus(OrderStatusEnum.CANCEL.getCode());
-
-            // 订单结算状态:未结算  2026-03-27 lixl
-            orderParam.setwStatus(OrderWStateEnum.NO_ACCOUNT.getCode());
-
-            updateById(orderParam);
-            // 添加取消订单通知
-            orderNotificationService.sendCancelledNotification(orderNew);
-
-            // 添加取消订单通知（技师侧）
-            orderNotificationService.sendTechnicianCancelledNotification(orderNew);
-            return true;
-        } else {
-            return false;
-        }
-
+    public BigDecimal getTurnover(String id, Date startDate, Date endDate) {
+        return null;
     }
 
     @Override
-    public TOrder getByNo(String orderNo) {
-        LambdaQueryWrapper<TOrder> objectLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        return this.getOne(objectLambdaQueryWrapper.eq(TOrder::getOrderNo, orderNo));
+    public TOrder transferOrder(TOrder order) {
+        return null;
     }
 
-//    private TOrder gettOrder(TOrder order) {
-//        LambdaUpdateWrapper<TOrder> objectLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
-//        objectLambdaUpdateWrapper.eq(TOrder::getOrderNo, order.getOrderNo());
-//        return this.getOne(objectLambdaUpdateWrapper);
-//    }
-
-
     @Override
-    public Page<TOrder> getAll(Page<TOrder> page, TOrder order) {
-        Page<TOrder> orderPage = orderMapper.getAll(page, order);
-        if (orderPage != null && CollectionUtil.isNotEmpty(orderPage.getRecords())) {
-
-            ArrayList<TOrder> ordersList = Lists.newArrayList();
-            orderPage.getRecords().forEach(orders -> {
-                orders.setStatusName(OrderStatusEnum.getDescByCode(orders.getnStatus()));
-                orders.setJsPhone(orders.getJs().getcPhone());
-                orders.setJsName(orders.getJs().getcName());
-                if (StringUtils.isEmpty(orders.getcTime())) {
-                    orders.setRemainingTime(0L);
-                }
-                if (StringUtils.isNotBlank(orders.getcTime()) && DateTimeUtils.dateStringToStamp(orders.getcTime()) > DateTimeUtils.dateToStamp(new Date())) {
-                    orders.setRemainingTime((DateTimeUtils.dateStringToStamp(orders.getcTime()) - DateTimeUtils.dateToStamp(new Date())) / 1000);
-                }
-                if (StringUtils.isNotBlank(orders.getcTime()) && DateTimeUtils.dateStringToStamp(orders.getcTime()) < DateTimeUtils.dateToStamp(new Date())) {
-                    orders.setRemainingTime(0L);
-                }
-                if (StringUtils.isNotBlank(orders.getOldJsId())) {
-                    orders.setOldJs(jsService.getById(orders.getOldJsId()));
-                }
-                // 计算已服务时长
-                Long serviceDuration = calculateServiceDuration(orders);
-                orders.setServiceDuration(String.valueOf(serviceDuration));
-
-                //项目名称
-                orders.setProjectNames(getProjectNames(orders));
-                //订单金额
-                orders.setOrderPrice(String.valueOf(orders.getTotalPrice()));
-                //优惠券补贴
-                orders.setCouponPrice(String.valueOf(orders.getPreferential()));
-                //实付金额
-                orders.setRealPayPrice(String.valueOf(orders.getTotalPrice()));
-                //平台佣金比例
-                orders.setPercent(percent.substring(percent.length() - 1)+"%");
-                //商户应收金额 不进行四舍五入
-                BigDecimal rp = orders.getTotalPrice().multiply(new BigDecimal(hPercent)).
-                        setScale(2, RoundingMode.DOWN);
-                orders.setrPrice(String.valueOf(rp));
-                //平台佣金
-                BigDecimal cp = orders.getTotalPrice().subtract(rp).
-                        setScale(2, RoundingMode.DOWN);
-                orders.setyPrice(String.valueOf(cp));
-                ordersList.add(orders);
-
-            });
-            orderPage.setRecords(ordersList);
-        }
-        return orderPage;
-    }
-
-
-    /**
-     * 计算已服务时长（分钟）
-     *
-     * @param order 订单对象
-     * @return Long 已服务时长（分钟）
-     */
-    private Long calculateServiceDuration(TOrder order) {
-        try {
-            LocalDateTime startTime = order.getStartTime();
-            LocalDateTime endTime = order.getEndTime();
-
-            if (startTime != null && endTime != null) {
-                long minutes = Duration.between(startTime, endTime).toMinutes();
-                if (minutes > 0) {
-                    return minutes;
-                }
-            } else if (startTime != null) {
-                // 如果只有开始时间，计算到现在的时长
-                long minutes = Duration.between(startTime, LocalDateTime.now()).toMinutes();
-                if (minutes > 0) {
-                    return minutes;
-                }
-            }
-        } catch (Exception e) {
-            log.warn("计算服务时长失败，订单ID：{}", order.getcId(), e);
-        }
-        return 0L;
+    public List<HomeBlock> getBlock(Date start, Date end, String deptId) {
+        return Collections.emptyList();
     }
 
     @Override
-    @Transactional(rollbackFor = Exception.class)
-    public void takingOrders(TOrder order) {
-        String orderId = order.getcId();
-        if (orderId == null || StringUtils.isBlank(orderId)) {
-            throw new IllegalArgumentException("订单ID不能为空");
-        }
-
-        TOrder orderNew = this.getById(orderId);
-
-        // 【新增】订单状态锁校验 - 检查技师是否可以接单
-        log.info("开始校验技师 {} 是否可以接单，订单号：{}", orderNew.getcJsId(), orderNew.getOrderNo());
-        orderValidationService.canAcceptOrder(orderNew.getcJsId(), orderNew);
-        log.info("技师 {} 接单校验通过，继续接单流程", orderNew.getcJsId());
-
-        // 检查订单对应的技师是否存在
-//        updateJs (orderNew);
-        TOrder orderParam = new TOrder();
-        orderParam.setcId(orderId);
-        //设置订单状态：已接单
-        orderParam.setnStatus(OrderStatusEnum.RECEIVED_ORDER.getCode());
-        orderParam.setAcceptanceTime(LocalDateTime.now());
-        this.updateById(orderParam);
-
-        // 已接单消息通知（用户侧）
-        orderNotificationService.sendReceivedNotification(orderNew);
-        // 已接单消息通知（技师侧）
-        orderNotificationService.sendTechnicianReceivedNotification(orderNew);
+    public OrderVerificationVo verification(TOrder order) {
+        return null;
     }
 
-    private void updateJs(TOrder orderNew) {
-        TJs js = jsService.getById(orderNew.getcJsId());
-        if (js == null) {
-            throw new IllegalStateException("无法找到对应的技师");
-        }
-
-        if (Objects.equals(js.getnStatus(), JsStatusEnum.JS_SERVICEABLE.getCode())) {
-            // 更新技师状态
-            js.setnStatus(JsStatusEnum.JS_SERVICE.getCode());
-            // 确保js.getnNum()不为null，避免 NullPointerException
-            int num = js.getnNum() == null ? 0 : js.getnNum();
-            js.setnNum(num + MassageConstants.INTEGER_ONE);
-        } else {
-            // 更新技师状态
-            js.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
-            // 确保js.getnNum()不为null，避免 NullPointerException
-            int num = js.getnNum() == null ? 0 : js.getnNum();
-            js.setnNum(num - MassageConstants.INTEGER_ONE);
-        }
-        jsService.updateById(js);
+    @Override
+    public TechnicianAvailabilityVo getTechnicianAvailability(String technicianId, String dateStr) {
+        return null;
     }
 
-    /**
-     * 申请取消订单（退单申请）
-     * 业务流程：
-     * 1. 校验订单状态（仅进行中的订单可申请退单）
-     * 2. 创建退单申请记录
-     * 3. 更新订单状态为"退单待审核"
-     *
-     * @param cId 订单对象
-     * @param cancelReason 订单对象
-     * @return Boolean 申请结果
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public Boolean applyCancle(String cId, String cancelReason) {
-        log.info("开始处理退单申请，订单ID：{}", cId);
-
-        // 1. 参数校验
-        if (StringUtils.isBlank(cId)) {
-            throw new ServiceException("订单ID不能为空");
-        }
-        if (StringUtils.isBlank(cancelReason)) {
-            throw new ServiceException("退单原因不能为空");
-        }
-
-        // 2. 根据订单ID查询订单信息
-        TOrder existingOrder = this.getById(cId);
-        if (existingOrder == null) {
-            throw new ServiceException("订单不存在");
-        }
-
-        // 3. 创建退单申请记录（内部会校验订单状态和其他业务规则）
-        String applicationId;
-        try {
-            applicationId = cancelOrderApplicationService.createApplication(existingOrder.getcId(), cancelReason);
-            log.info("退单申请记录创建成功，申请ID：{}", applicationId);
-        } catch (ServiceException e) {
-            log.error("创建退单申请失败：{}", e.getMessage());
-            throw e;
-        }
-
-        // 4. 更新订单状态为"退单待审核"
-        existingOrder.setnStatus(OrderStatusEnum.CANCEL_APPLICATION_PENDING.getCode());
-        this.updateById(existingOrder);
-
-        log.info("退单申请处理完成，订单ID：{}，申请ID：{}", existingOrder.getcId(), applicationId);
-        return Boolean.TRUE;
+        return null;
     }
 
-    /**
-     * 取消退单申请
-     * 用户主动取消退单申请，恢复订单状态
-     *
-     * 业务流程：
-     * 1. 参数校验（订单ID不能为空）
-     * 2. 查询订单和退单申请记录
-     * 3. 校验订单状态必须为"退单待审核"(6)
-     * 4. 校验退单审核状态必须为"待审核"(0)
-     * 5. 调用退单申请服务取消申请
-     * 6. 恢复订单状态到申请前的原始状态
-     *
-     * @param order 订单对象，需要包含cId（订单ID）
-     * @return Boolean 操作结果
-     */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public Boolean cancelApplyCancle(TOrder order) {
-        log.info("开始取消退单申请，订单ID：{}", order.getcId());
-
-        // 1. 参数校验
-        if (StringUtils.isBlank(order.getcId())) {
-            throw new ServiceException("订单ID不能为空");
-        }
-
-        // 2. 查询订单信息
-        TOrder existingOrder = this.getById(order.getcId());
-        if (existingOrder == null) {
-            throw new ServiceException("订单不存在");
-        }
-
-        // 3. 校验订单状态 - 只有"退单待审核"状态的订单才能取消申请
-        Integer currentStatus = existingOrder.getnStatus();
-        if (!OrderStatusEnum.CANCEL_APPLICATION_PENDING.getCode().equals(currentStatus)) {
-            throw new ServiceException("当前订单状态不允许取消退单申请");
-        }
-
-        // 4. 查询退单申请记录
-        com.ylx.massage.domain.CancelOrderApplication application = cancelOrderApplicationService.getInfoByOrderId(order.getcId());
-        if (application == null) {
-            throw new ServiceException("退单申请记录不存在");
-        }
-
-        // 5. 校验退单申请状态 - 只有"待审核"的申请才能取消
-        if (application.getAuditStatus() != 0) {
-            throw new ServiceException("当前退单申请状态不允许取消");
-        }
-
-        // 6. 获取订单原始状态（在申请退单时保存的状态）
-        Integer originalStatus = application.getOrderStatus();
-        if (originalStatus == null) {
-            throw new ServiceException("无法获取订单原始状态，取消申请失败");
-        }
-
-        // 7. 调用退单申请服务取消申请
-        try {
-            cancelOrderApplicationService.cancelApplication(order.getcId());
-            log.info("退单申请记录取消成功，订单ID：{}", order.getcId());
-        } catch (ServiceException e) {
-            log.error("取消退单申请失败：{}", e.getMessage());
-            throw e;
-        }
-
-        // 8. 恢复订单状态到原始状态
-        existingOrder.setnStatus(originalStatus);
-        boolean updated = this.updateById(existingOrder);
-        if (!updated) {
-            throw new ServiceException("恢复订单状态失败");
-        }
-        log.info("取消退单申请处理完成，订单ID：{}，恢复到状态：{}", order.getcId(), originalStatus);
-        return Boolean.TRUE;
+        return null;
     }
 
     @Override
-    public Page<TOrder> getPcOrderIncome(Page<TOrder> page, TOrder o) {
-        Page<TOrder> orderPage = orderMapper.getAll(page, o);
-        if (orderPage != null && CollectionUtil.isNotEmpty(orderPage.getRecords())) {
-
-            ArrayList<TOrder> ordersList = Lists.newArrayList();
-            orderPage.getRecords().forEach(order -> {
-                order.setStatusName(OrderStatusEnum.getDescByCode(order.getnStatus()));
-                order.setJsPhone(order.getJs().getcPhone());
-                order.setJsName(order.getJs().getcName());
-                //项目名称
-                order.setProjectNames(getProjectNames(order));
-                //订单金额
-                order.setOrderPrice(String.valueOf(order.getTotalPrice()));
-                //优惠券补贴
-                order.setCouponPrice(String.valueOf(order.getPreferential()));
-                //实付金额
-                order.setRealPayPrice(String.valueOf(order.getTotalPrice()));
-                //平台佣金比例
-                order.setPercent(percent.substring(percent.length() - 1)+"%");
-                //商户应收金额 不进行四舍五入
-                BigDecimal rp = order.getTotalPrice().multiply(new BigDecimal(hPercent)).
-                        setScale(2, RoundingMode.DOWN);
-                order.setrPrice(String.valueOf(rp));
-                //平台佣金
-                BigDecimal cp = order.getTotalPrice().subtract(rp).
-                        setScale(2, RoundingMode.DOWN);
-                order.setyPrice(String.valueOf(cp));
-                ordersList.add(order);
-
-            });
-            orderPage.setRecords(ordersList);
-        }
-        return orderPage;
+    public Page<TOrder> getPcOrderIncome(Page<TOrder> page, TOrder order) {
+        return null;
     }
 
-    /**
-     * 累计营业收入  累计平台佣金收入  累计商家收入
-     * @return
-     */
     @Override
     public Map<String, String> totalData(TOrder order) {
-        //订单状态(-1：待付款 0：待接单 1：已接单 6：已出发 2：已到达 3：服务中 4：待评价
-        //5：已完成 7：退单待审核 8：退单审核通过  -2：已取消 -3：已拒绝)
-
-        // 过滤 待付款 退单审核通过 已取消 已拒绝
-        List<TOrder> listOrder = baseMapper.getAll(order);
-
-        Map<String, String> map = new HashMap<>();
-        final BigDecimal[] total1 = {BigDecimal.ZERO};
-        final BigDecimal[] total2 = {BigDecimal.ZERO};
-        BigDecimal total3 = BigDecimal.ZERO;
-        listOrder.forEach(o -> {
-            total1[0] = total1[0].add(null == o.getTotalPrice() ? BigDecimal.ZERO : o.getTotalPrice());
-            total2[0] = total2[0].add(null == o.getTotalPrice() ? BigDecimal.ZERO : o.getTotalPrice().
-                    multiply(new BigDecimal(hPercent)).setScale(2, RoundingMode.DOWN));
-        });
-        total3 = total1[0].subtract(total2[0]).setScale(2, RoundingMode.DOWN);
-        map.put("totalPrice", total1[0].toString());
-        map.put("merchantPrice", total2[0].toString());
-        map.put("platformPrice", total3.toString());
-        return map;
+        return Collections.emptyMap();
     }
 
     @Override
     public void callAutoAccount(int hCount, BigDecimal percent) {
-        baseMapper.callAutoAccount(hCount, percent);
+
     }
 
-    /**
-     * 商户收益，总额，待结算，已结算，已提现
-     * @param user
-     * @return
-     */
+    @Override
     public Map<String, String> myIncome(TWxUser user) {
-        List<TOrder> orderList = getTOrders(user, null);
-        Map<String, String> result = new HashMap<>();
-        // 我的收益 = 待结算 + 已结算
-        if(CollectionUtil.isNotEmpty(orderList)){
-            // 所有订单的总金额
-            BigDecimal tAmount = orderList.stream()
-                    .filter(order -> (order.getTotalPrice()!=null && order.getTotalPrice().compareTo(BigDecimal.ZERO) > 0))
-                    .map(TOrder::getTotalPrice)
-                    .reduce(BigDecimal.ZERO, BigDecimal::add);
-            tAmount = tAmount.multiply(new BigDecimal(hPercent)).setScale(2, RoundingMode.DOWN);
-            // 已结算订单的总金额
-            BigDecimal yAmount = orderList.stream()
-                    .filter(order -> OrderWStateEnum.OK_ACCOUNT.getCode().intValue() == order.getwStatus().intValue())
-                    .map(TOrder::getTotalPrice)
-                    .reduce(BigDecimal.ZERO, BigDecimal::add);
-            yAmount = yAmount.multiply(new BigDecimal(hPercent)).setScale(2, RoundingMode.DOWN);
-            // 待结算订单的总金额
-            BigDecimal wAmount = orderList.stream()
-                    .filter(order -> OrderWStateEnum.WAIT_ACCOUNT.getCode().intValue() == order.getwStatus().intValue())
-                    .map(TOrder::getTotalPrice)
-                    .reduce(BigDecimal.ZERO, BigDecimal::add);
-            wAmount = wAmount.multiply(new BigDecimal(hPercent)).setScale(2, RoundingMode.DOWN);
-            result.put("tAmount", tAmount.toPlainString());
-            result.put("yAmount", yAmount.toPlainString());
-            result.put("wAmount", wAmount.toPlainString());
-
-        }
-        List<TTxRecord> tTxRecords = recordService.tTxRecordList(user.getcOpenid());
-        if(CollectionUtil.isNotEmpty(tTxRecords)){
-            // 已提现
-            BigDecimal gAmount = tTxRecords.stream()
-                    .filter(order -> (order.getdPrice()!=null && order.getdPrice().compareTo(BigDecimal.ZERO) > 0))
-                    .map(TTxRecord::getdPrice)
-                    .reduce(BigDecimal.ZERO, BigDecimal::add);
-            result.put("gAmount", gAmount.toPlainString());
-        }
-        result.put("tAmount", StringUtils.isNotBlank(result.get("tAmount"))?result.get("tAmount"):"0.00");
-        result.put("yAmount", StringUtils.isNotBlank(result.get("yAmount"))?result.get("yAmount"):"0.00");
-        result.put("wAmount", StringUtils.isNotBlank(result.get("wAmount"))?result.get("wAmount"):"0.00");
-        result.put("gAmount", StringUtils.isNotBlank(result.get("gAmount"))?result.get("gAmount"):"0.00");
-        return result;
+        return Collections.emptyMap();
     }
 
-    /**
-     * 商户收入明细
-     * @param user
-     * @param wStatus
-     * @return
-     */
+    @Override
     public List<Map<String, Object>> myIncomeDetail(TWxUser user, Integer wStatus) {
-        List<TOrder> orderList = getTOrders(user, wStatus);
-        Map<YearMonth, List<TOrder>> sortedMonthlyGroupedOrders = new HashMap<>();
-        List<Map<String, Object>> listResult = new ArrayList<>();
-        if(CollectionUtil.isNotEmpty(orderList)){
-            orderList.forEach(item->{
-                //商户应收金额 不进行四舍五入
-                if(!Objects.isNull(item.getTotalPrice())){
-                    item.setrPrice(String.valueOf(item.getTotalPrice().multiply(new BigDecimal(hPercent)).
-                            setScale(2, RoundingMode.DOWN)));
-                }
-                item.setProjectNames(getProjectNames(item));
-            });
-
-            Map<YearMonth, List<TOrder>> monthlyGroupedOrders = orderList.stream()
-                    .collect(Collectors.groupingBy(
-                            order -> YearMonth.from(order.getDtCreateTime()),
-                            Collectors.collectingAndThen(
-                                    Collectors.toList(),
-                                    list -> list.stream()
-                                            .sorted(Comparator.comparing(TOrder::getDtCreateTime).reversed())
-                                            .collect(Collectors.toList())
-                            )
-                    ));
-            sortedMonthlyGroupedOrders = new TreeMap<>(Comparator.reverseOrder());
-            sortedMonthlyGroupedOrders.putAll(monthlyGroupedOrders);
-            for (Map.Entry<YearMonth, List<TOrder>> entry : sortedMonthlyGroupedOrders.entrySet()) {
-                YearMonth yearMonth = entry.getKey();
-                List<TOrder> tTxRecordList = entry.getValue();
-                Map<String, Object> newMap = new HashMap<>();
-                // 将新键和对应的值放入新的Map中
-                newMap.put("date", yearMonth);
-                newMap.put("records", tTxRecordList);
-                listResult.add(newMap);
-            }
-        }
-
-        return listResult;
-    }
-
-    /**
-     * 查询待结算/已结算订单
-     * @param user
-     * @return
-     */
-    private List<TOrder> getTOrders(TWxUser user, Integer wStatus) {
-        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(TOrder::getIsDelete, 0).
-                eq(com.ylx.common.utils.StringUtils.isNotBlank(user.getcOpenid()),TOrder::getcOpenId, user.getcOpenid()).
-                eq(wStatus != null, TOrder::getwStatus, wStatus).
-                // 过滤 待付款 退单审核通过 已取消 已拒绝
-                ne(TOrder::getnStatus, OrderStatusEnum.WAIT_PAY.getCode()).
-                ne(TOrder::getnStatus, OrderStatusEnum.CANCEL_APPLICATION_PASS.getCode()).
-                ne(TOrder::getnStatus, OrderStatusEnum.CANCEL.getCode()).
-                ne(TOrder::getnStatus, OrderStatusEnum.REFUSE.getCode()).
-                orderByDesc(TOrder::getDtCreateTime);
-        return orderMapper.selectList(queryWrapper);
+        return Collections.emptyList();
     }
-
-    private String getProjectNames(TOrder order) {
-        List<TXiangmu> list = JSONObject.parseArray(order.getcGoods().toJSONString(), TXiangmu.class);
-        StringBuilder sb = new StringBuilder();
-        for (TXiangmu xiangmu : list) {
-            sb.append(xiangmu.getcTitle()).append(",");
-        }
-        // 移除最后一个逗号
-        if (sb.length() > 0) {
-            sb.setLength(sb.length() - 1);
-        }
-        return sb.toString();
-    }
-
 }