guyue
5 天以前 e285517df2a3cb206282a41f958c80044422a552
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package com.linghu.controller;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.util.BeanUtil;
import com.linghu.model.common.ResponseResult;
import com.linghu.model.entity.Order;
import com.linghu.model.dto.OrderDto;
import com.linghu.service.OrderService;
 
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
 
/**
 * 订单管理接口
 */
@RestController
@RequestMapping("/order")
public class OrderController {
 
    @Autowired
    private OrderService orderService;
 
    /**
     * 新增订单
     */
    @PostMapping
    public ResponseResult<Order> add(@RequestBody OrderDto orderDto) {
        //将dto转entity
        Order order = new Order();
        BeanUtils.copyProperties(orderDto, order);
 
        if (order.getClient_name() == null || order.getClient_name().trim().isEmpty()) {
            return ResponseResult.error("客户名称不能为空");
        }
 
        // 生成订单ID:日期+当天的订单数量(如:202507060001)
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String dateStr = dateFormat.format(new Date());
 
        // 查询当天订单数量
        LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.likeRight(Order::getOrder_id, dateStr);
        long count = orderService.count(queryWrapper);
 
        // 生成订单ID
        String orderId = String.format("%s%04d", dateStr, count + 1);
        order.setOrder_id(orderId);
 
        // 设置初始状态
        order.setStatus(1); // 待处理
        order.setDel_flag(0); // 未删除
        order.setCreate_time(new Date());
        //保存关键词
        boolean saveOrderWithKeywords = orderService.saveOrderWithKeywords(orderDto);
      
 
        if (orderService.save(order)) {
            return ResponseResult.success(order);
        }
        return ResponseResult.error("添加订单失败");
    }
 
    /**
     * 删除订单(逻辑删除)
     */
    @DeleteMapping("/{orderId}")
    public ResponseResult<Void> delete(@PathVariable String orderId) {
        Order order = orderService.getById(orderId);
        if (order == null) {
            return ResponseResult.error("订单不存在");
        }
 
        order.setDel_flag(1);
        order.setUpdate_time(new Date());
 
        if (orderService.updateById(order)) {
            return ResponseResult.success();
        }
        return ResponseResult.error("删除订单失败");
    }
 
    /**
     * 更新订单
     */
    @PutMapping
    public ResponseResult<Void> update(@RequestBody Order order) {
        if (order.getOrder_id() == null) {
            return ResponseResult.error("订单ID不能为空");
        }
        if (order.getClient_name() == null || order.getClient_name().trim().isEmpty()) {
            return ResponseResult.error("客户名称不能为空");
        }
 
        Order existingOrder = orderService.getById(order.getOrder_id());
        if (existingOrder == null) {
            return ResponseResult.error("订单不存在");
        }
 
        order.setUpdate_time(new Date());
 
        if (orderService.updateById(order)) {
            return ResponseResult.success();
        }
        return ResponseResult.error("更新订单失败");
    }
 
    /**
     * 根据ID查询订单
     */
    @GetMapping("/{orderId}")
    public ResponseResult<Order> getById(@PathVariable String orderId) {
        Order order = orderService.getById(orderId);
        if (order == null || order.getDel_flag() == 1) {
            return ResponseResult.error("订单不存在");
        }
        return ResponseResult.success(order);
    }
 
    /**
     * 查询订单列表
     */
    @GetMapping
    public ResponseResult<List<Order>> list(
            @RequestParam(required = false) Integer pageNum,
            @RequestParam(required = false) Integer pageSize,
            @RequestParam(required = false) String clientName,
            @RequestParam(required = false) Integer status) {
 
        LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Order::getDel_flag, 0); // 只查询未删除的订单
 
        // 添加查询条件
        if (clientName != null && !clientName.trim().isEmpty()) {
            queryWrapper.like(Order::getClient_name, clientName);
        }
        if (status != null) {
            queryWrapper.eq(Order::getStatus, status);
        }
 
        // 分页查询
        if (pageNum != null && pageSize != null) {
            Page<Order> pageInfo = new Page<>(pageNum, pageSize);
            Page<Order> result = orderService.page(pageInfo, queryWrapper);
            return ResponseResult.success(result.getRecords());
        }
 
        // 不分页
        List<Order> list = orderService.list(queryWrapper);
        return ResponseResult.success(list);
    }
}