feat: 代码重构

hjl

2024-07-18 b9da8289051937fbbbd47bbda97414ad6c769a90

 ruoyi-service/ruoyi-admin/src/main/java/com/ruoyi/admin/controller/OrderController.java

@@ -1,33 +1,33 @@
package com.ruoyi.admin.controller;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.admin.entity.MasterWorker;
import com.ruoyi.admin.entity.Order;
import com.ruoyi.admin.request.OrderQueryRequest;
import com.ruoyi.admin.service.MasterWorkerService;
import com.ruoyi.admin.service.OrderService;
import com.ruoyi.admin.entity.RecoveryServe;
import com.ruoyi.admin.entity.Site;
import com.ruoyi.admin.service.*;
import com.ruoyi.admin.sorcket.WebSocketServer;
import com.ruoyi.admin.vo.OrderCountVO;
import com.ruoyi.admin.vo.OrderDetailVO;
import com.ruoyi.admin.vo.OrderPageCountVO;
import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.utils.SnowflakeIdWorker;
import com.ruoyi.common.core.utils.bean.BeanUtils;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.api.entity.*;
import com.ruoyi.order.api.feignClient.ExchangeDispatchClient;
import com.ruoyi.order.api.feignClient.OrderClient;
import com.ruoyi.system.api.model.LoginUser;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -47,24 +47,24 @@
    private OrderService orderService;
    @Resource
    private MasterWorkerService masterWorkerService;
    @Resource
    private RecoveryServeService recoveryServeService;
    @Resource
    private SiteService siteService;
    @Resource
    private OrderClient orderClient;
    @Resource
    private ExchangeDispatchClient dispatchClient;
    @Resource
    private TokenService tokenService;
    @Resource
    private FranchiseeService franchiseeService;

    /**
     * 雪花算法类
     */
    private static final SnowflakeIdWorker SNOW_FLAKE_ID_WORKER = new SnowflakeIdWorker(5, 5);

    /**
     * socket测试
     */
    @ApiOperation(value = "socket测试", tags = {"后台-订单管理"})
    @GetMapping(value = "/socketTest")
    public R<String> socketTest(@RequestParam String msg, @RequestParam String id) {
        try {
            WebSocketServer.sendInfo(msg, id);
            return R.ok("消息推送成功！");
        } catch (IOException e) {
            return R.fail();
        }
    }

    /**
     * 根据前台用户id查询所有订单信息
@@ -77,7 +77,7 @@
            @ApiImplicitParam(value = "手机号", name = "phone", dataType = "String", required = true)
    })
    public R<List<Order>> queryList(@RequestParam("phone") String phone) {
        return R.ok(orderService.lambdaQuery().eq(Order::getReservationPhone, phone).eq(Order::getIsDelete, 0).list());
        return R.ok(orderClient.queryList(phone).getData());
    }

    /**
@@ -92,7 +92,8 @@
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "id", dataType = "Integer", required = true)
    })
    public R<OrderDetailVO> detail(@RequestParam String id) {
    public R<OrderDetailVO> orderDetail(@RequestParam String id) {
        // 独立orderService
        return R.ok(orderService.orderListDetail(id));
    }

@@ -103,52 +104,106 @@
     */
    @ApiOperation(value = "订单列表-分页", tags = {"后台-订单管理"})
    @PostMapping(value = "/queryPage")
    public R<IPage<Order>> queryPage(@RequestBody OrderQueryRequest orderQueryRequest) {
        return R.ok(orderService.queryPage(orderQueryRequest));
    public R<Page<Order>> queryPage(@RequestBody OrderQueryRequest orderQueryRequest) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (null == loginUser) {
            return R.loginExpire("登录失效！");
        }
        if (loginUser.getIsFranchisee()) {
            orderQueryRequest.setCityList(loginUser.getCityList());
        }
        Page<Order> data = orderClient.queryPage(orderQueryRequest).getData();
        if (null != data) {
            for (Order record : data.getRecords()) {
                // 回收服务信息
                Integer serverId = record.getServerId();
                MasterWorker masterWorker = masterWorkerService.lambdaQuery()
                        .eq(MasterWorker::getId, serverId)
                        .eq(MasterWorker::getIsDelete, 0).one();
                if (null != masterWorker) {
                    record.setServerName(masterWorker.getRealName());
                    record.setServerPhone(masterWorker.getPhone());
                }
            }
        }
        return R.ok(data);
    }

    /**
     * 订单列表
     *
     * @param orderQueryRequest 订单列表查询参数
     */
    @ApiOperation(value = "订单列表-各订单数量统计", tags = {"后台-订单管理"})
    @PostMapping(value = "/orderPageCount")
    public R<OrderPageCountVO> orderPageCount(@RequestBody OrderQueryRequest orderQueryRequest) {
        return R.ok(orderService.orderPageCount(orderQueryRequest));
        return R.ok(orderClient.orderPageCount(orderQueryRequest).getData());
    }

    /**
     * 站点详情
     *
     * @param id 站点id
     * @param id 订单id
     */
    @ApiOperation(value = "订单列表-订单详情", tags = {"后台-订单管理"})
    @GetMapping(value = "/detail")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "站点id", name = "id", dataType = "Integer", required = true)
            @ApiImplicitParam(value = "订单id", name = "id", dataType = "Integer", required = true)
    })
    public R<Order> detail(@RequestParam Integer id) {
        return R.ok(orderService.getById(id));
    public R<Order> detail(@RequestParam String id) {
        return R.ok(orderClient.detail(id).getData());
    }

    /**
     * 新增订单
     * 后台订单与用户端及师傅端无关联
     * 后台订单为指定订单，默认为待上门状态
     *
     * @param order 站点信息
     */
    @ApiOperation(value = "订单列表-新增订单", tags = {"后台-订单管理"})
    @PostMapping(value = "/save")
    public R<String> save(@RequestBody Order order) {
    public R<String> save(@RequestBody OrderRequest order) {
        // 站点信息
        Site site = siteService.lambdaQuery()
                .eq(Site::getId, order.getSiteId())
                .eq(Site::getIsDelete, 0).one();
        order.setSiteName(site.getSiteName());
        // 师傅信息
        if (null != order.getServerId()) {
            MasterWorker masterWorker = masterWorkerService.lambdaQuery()
                    .eq(MasterWorker::getId, order.getServerId())
                    .eq(MasterWorker::getIsDelete, 0).one();
            order.setServerName(masterWorker.getRealName());
            order.setServerPhone(masterWorker.getPhone());
            // 待上门
            order.setState(Constants.ONE);
        } else {
            // 待派单状态
            order.setState(Constants.ZERO);
        }
        // 后台订单
        order.setType(Constants.ONE);
        order.setSubsidy(BigDecimal.ZERO);
        order.setOrderNumber(String.valueOf(SNOW_FLAKE_ID_WORKER.nextId()));
        return orderService.save(order) ? R.ok() : R.fail();
        // 回收服务信息
        RecoveryServe recoveryServe = recoveryServeService.lambdaQuery()
                .eq(RecoveryServe::getId, order.getServeId())
                .eq(RecoveryServe::getIsDelete, 0).one();
        order.setServeName(recoveryServe.getServeName());
        order.setServePrice(recoveryServe.getDefaultPrice());
        order.setOrderMoney(recoveryServe.getDefaultPrice());
        Boolean data = orderClient.save(order).getData();
        if (null == data) {
            return R.fail(orderClient.save(order).getMsg());
        }
        try {
            WebSocketServer.sendInfo("您有一条新的订单，请注意查收！", String.valueOf(order.getServerId()));
        } catch (IOException e) {
            return R.fail("订单推送失败！");
        }
        return data ? R.ok() : R.fail();
    }

    /**
     * 新增订单
     * 后台订单与用户端及师傅端无关联
     * 订单派单/改派
     *
     * @param type 1:订单派单；2:订单改派
     */
@@ -157,34 +212,43 @@
    @ApiImplicitParams({
            @ApiImplicitParam(value = "操作类型(1:订单派单；2:订单改派)", name = "type", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "订单id", name = "orderId", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "服务人员id", name = "workerId", dataType = "Integer", required = true)
            @ApiImplicitParam(value = "服务人员id", name = "workerId", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "改派原因", name = "applyReason", dataType = "String")
    })
    public R<String> reassignment(@RequestParam Integer type, @RequestParam Integer orderId,
                                  @RequestParam Integer workerId) {
        Order order = orderService.lambdaQuery().eq(Order::getId, orderId).eq(Order::getIsDelete, 0).one();
    @Transactional(rollbackFor = Exception.class)
    public R<String> reassignment(@RequestParam Integer type, @RequestParam String orderId,
                                  @RequestParam Integer workerId, String applyReason) {
        MasterWorker masterWorker = masterWorkerService.lambdaQuery()
                .eq(MasterWorker::getId, workerId)
                .eq(MasterWorker::getIsDelete, 0).one();
        Order item = orderClient.detail(orderId).getData();
        Order order = orderClient.exchangeOrder(type, orderId, workerId,
                masterWorker.getRealName(), masterWorker.getPhone()).getData();
        // 订单派单
        boolean result = true;
        if (Constants.ONE.equals(type)) {
            order.setServerId(workerId);
            order.setServerName(masterWorker.getRealName());
            order.setServerPhone(masterWorker.getPhone());
            order.setAcceptTime(new Date());
            result = orderService.updateById(order);
        } else if (Constants.TWO.equals(type)) {
            order.setState(Constants.FIVE);
            orderService.updateById(order);
            Order itemOrder = new Order();
            BeanUtils.copyProperties(order, itemOrder);
            itemOrder.setId(null);
            itemOrder.setServerId(workerId);
            itemOrder.setServerName(masterWorker.getRealName());
            itemOrder.setServerPhone(masterWorker.getPhone());
            itemOrder.setAcceptTime(new Date());
            itemOrder.setState(Constants.ONE);
            result = orderService.save(itemOrder);
        if (Constants.TWO.equals(type)) {
            if (order.getState().equals(Constants.SIX) || order.getState().equals(Constants.THREE)) {
                orderClient.updateState(order.getId(), Constants.ONE);
            }
            // 订单状态为 待完工时，需要更改状态 待上门且清空师傅到达预约点时间
            if (order.getState().equals(Constants.TWO)) {
                orderClient.updateStateAndArrivalTime(orderId, Constants.ONE);
            }
            // 生成改派信息
            ChangeDispatch changeDispatch = new ChangeDispatch();
            changeDispatch.setWorkerId(item.getServerId());
            changeDispatch.setWorkerName(item.getServerName());
            changeDispatch.setApplyReason(applyReason);
            changeDispatch.setApplyTime(new Date());
            changeDispatch.setState(Constants.ONE);
            changeDispatch.setOrderId(orderId);
            changeDispatch.setOrderNumber(item.getOrderNumber());
            if (null != item.getUserId()) {
                changeDispatch.setUserId(item.getUserId());
            }
            changeDispatch.setUserName(item.getReservationName());
            changeDispatch.setIsDelete(Constants.ZERO);
            result = dispatchClient.saveRecord(changeDispatch).getData();
        }
        try {
            WebSocketServer.sendInfo("您有一条新的订单，请注意查收！", String.valueOf(workerId));
@@ -204,22 +268,21 @@
    @ApiImplicitParams({
            @ApiImplicitParam(value = "多个id ',' 拼接", name = "ids", dataType = "String", required = true)
    })
    public R<String> batchDelete(@RequestParam String ids) {
        List<String> idList = Arrays.stream(ids.split(",")).collect(Collectors.toList());
        List<Order> list = orderService.lambdaQuery().in(Order::getId, idList).list();
        list.forEach(data -> data.setIsDelete(1));
        return orderService.updateBatchById(list) ? R.ok() : R.fail();
    public R<Boolean> batchDelete(@RequestParam String ids) {
        return R.ok(orderClient.batchDelete(ids).getData());
    }

    /**
     * 订单列表-excel导出
     *
     * @param idList 订单id
     * @param orderQueryRequest 筛选参数
     */
    @ApiOperation(value = "订单列表-excel导出", tags = {"后台-订单管理"})
    @PostMapping(value = "/excelExport")
    public R<String> excelExport(@RequestBody List<String> idList, HttpServletResponse response) {
        return orderService.excelExport(idList, response);
    public R<String> excelExport(@RequestBody OrderQueryRequest orderQueryRequest, HttpServletResponse response) {
        R<List<Order>> result = orderClient.excelExport(orderQueryRequest);
        // 独立orderService
        return orderService.excelExport(result.getData(), response);
    }

    /**
@@ -236,10 +299,31 @@
            @ApiImplicitParam(value = "页码", name = "pageNum", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "每页条数", name = "pageSize", dataType = "Integer", required = true)
    })
    public R<IPage<OrderCountVO>> orderCount(String name, String phone,
                                             @RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
                                             @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
        return R.ok(orderService.orderCount(name, phone, Page.of(pageNum, pageSize)));
    public R<Page<OrderCountVO>> orderCount(String name, String phone,
                                            @RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
                                            @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
        Page<OrderCountVO> data = orderClient.orderCount(name, phone, pageNum, pageSize).getData();
        List<Integer> idList = data.getRecords().stream().map(OrderCountVO::getWorkerId)
                .collect(Collectors.toList());
        List<MasterWorker> masterWorkerList;
        if (!idList.isEmpty()) {
            masterWorkerList = masterWorkerService.lambdaQuery()
                    .in(MasterWorker::getId, idList)
                    .eq(MasterWorker::getIsDelete, 0).list();
        } else {
            masterWorkerList = masterWorkerService.lambdaQuery()
                    .eq(MasterWorker::getIsDelete, 0).list();
        }
        Map<Integer, String> profilePictureMap = masterWorkerList.stream().collect(Collectors.toMap(MasterWorker::getId,
                mw -> Optional.ofNullable(mw.getProfilePicture()).orElse("")));
        Map<Integer, String> realNameMap = masterWorkerList.stream().collect(Collectors.toMap(MasterWorker::getId,
                mw -> Optional.ofNullable(mw.getRealName()).orElse("")));
        for (OrderCountVO record : data.getRecords()) {
            Integer workerId = record.getWorkerId();
            record.setRealName(realNameMap.get(workerId));
            record.setProfilePicture(profilePictureMap.get(workerId));
        }
        return R.ok(data);
    }

}