package com.ruoyi.order.controller;
|
|
import cn.hutool.core.date.DateUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.ruoyi.common.core.constant.Constants;
|
import com.ruoyi.common.core.domain.BaseEntity;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.core.exception.GlobalException;
|
import com.ruoyi.common.core.vo.PaperInVo;
|
import com.ruoyi.common.core.vo.Path;
|
|
import com.ruoyi.order.entity.*;
|
import com.ruoyi.order.request.OrderCountDataRequest;
|
import com.ruoyi.order.request.OrderRequest;
|
import com.ruoyi.order.request.OrderSubmitRequest;
|
import com.ruoyi.order.request.UserOrderRequest;
|
import com.ruoyi.order.service.*;
|
import com.ruoyi.order.vo.*;
|
import com.ruoyi.user.api.feignClient.UserClient;
|
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 java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 订单管理 前端控制器
|
* </p>
|
*
|
* @author hjl
|
* @since 2024-05-29
|
*/
|
@RestController
|
@RequestMapping("/order")
|
@Api(tags = {"后台-订单管理"})
|
public class OrderController {
|
|
@Resource
|
private OrderService orderService;
|
@Resource
|
private ServeRecordService serveRecordService;
|
@Resource
|
private EvaluateService evaluateService;
|
@Resource
|
private ServeCoordinateService serveCoordinateService;
|
@Resource
|
private ChangeDispatchService changeDispatchService;
|
|
/**
|
* 根据前台用户id查询所有订单信息
|
*
|
* @param phone 手机号
|
*/
|
@ApiOperation(value = "查询用户所有订单", tags = {"后台-订单管理"})
|
@GetMapping(value = "/queryList")
|
@ApiImplicitParams({
|
@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());
|
}
|
|
|
/**
|
* 订单列表
|
*
|
* @param orderQueryRequest 订单列表查询参数
|
*/
|
@ApiOperation(value = "订单列表-分页", tags = {"后台-订单管理"})
|
@PostMapping(value = "/queryPage")
|
public R<Page<Order>> queryPage(@RequestBody OrderQueryRequest orderQueryRequest) {
|
return R.ok(orderService.queryPage(orderQueryRequest));
|
}
|
|
/**
|
* 订单列表
|
*/
|
@ApiOperation(value = "订单列表-各订单数量统计", tags = {"后台-订单管理"})
|
@PostMapping(value = "/orderPageCount")
|
public R<OrderPageCountVO> orderPageCount(@RequestBody OrderQueryRequest orderQueryRequest) {
|
return R.ok(orderService.orderPageCount(orderQueryRequest));
|
}
|
|
/**
|
* 更改订单状态
|
*/
|
@ApiOperation(value = "订单列表-更改订单状态", tags = {"后台-订单管理"})
|
@PostMapping(value = "/updateState")
|
public R<Boolean> updateState(@RequestParam("orderId") String orderId,
|
@RequestParam("state") Integer state) {
|
return R.ok(orderService.lambdaUpdate()
|
.eq(Order::getId, orderId).set(Order::getState, state).update());
|
}
|
|
|
@ApiOperation(value = "订单列表-增加打印次数", tags = {"后台-订单管理"})
|
@PostMapping(value = "/count")
|
public R<Boolean> count(@RequestParam("orderId") String orderId) {
|
Order byId = orderService.getById(orderId);
|
byId.setPrintCount(byId.getPrintCount()==null?1:byId.getPrintCount()+1);
|
orderService.updateById(byId);
|
return R.ok();
|
}
|
|
@ApiOperation(value = "订单列表-获取入库单", tags = {"后台-订单管理"})
|
@PostMapping(value = "/papercount")
|
public R<List<PaperInVo>> inpaper(@RequestParam("workId") String workId,@RequestParam("date") String date) {
|
|
List<PaperInVo> paper = orderService.papercout(workId,date);
|
return R.ok(paper);
|
}
|
|
|
|
/**
|
* 更改订单状态且清空到达时间
|
*/
|
@ApiOperation(value = "订单列表-更改订单状态且清空到达时间", tags = {"后台-订单管理"})
|
@PostMapping(value = "/updateStateAndArrivalTime")
|
public R<Boolean> updateStateAndArrivalTime(@RequestParam("orderId") String orderId,
|
@RequestParam("state") Integer state) {
|
return R.ok(orderService.lambdaUpdate()
|
.eq(Order::getId, orderId).set(Order::getState, state)
|
.set(Order::getArriveTime, null).update());
|
}
|
|
/**
|
* 更改订单提现状态
|
*/
|
@ApiOperation(value = "订单列表-更改订单提现状态", tags = {"后台-订单管理"})
|
@PostMapping(value = "/updateWithdrawalState")
|
public R<Boolean> updateWithdrawalState(@RequestParam("orderId") String orderId,
|
@RequestParam("state") Integer state) {
|
return R.ok(orderService.lambdaUpdate()
|
.eq(Order::getId, orderId).set(Order::getIsWithdrawal, state).update());
|
}
|
|
/**
|
* 站点详情
|
*
|
* @param id 站点id
|
*/
|
@ApiOperation(value = "订单列表-订单详情", tags = {"后台-订单管理"})
|
@GetMapping(value = "/detailByExchangeId")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "改派申请id", name = "id", dataType = "Integer", required = true)
|
})
|
public R<Order> detailByExchangeId(@RequestParam("id") String id) {
|
ChangeDispatch changeDispatch = changeDispatchService.lambdaQuery()
|
.eq(ChangeDispatch::getOrderId, id)
|
.eq(ChangeDispatch::getIsDelete, 0).one();
|
if (null == changeDispatch) {
|
throw new GlobalException("改派申请信息不存在！");
|
}
|
return R.ok(orderService.lambdaQuery()
|
.eq(Order::getId, changeDispatch.getOrderId()).eq(Order::getIsDelete, 0).one());
|
}
|
|
/**
|
* 站点详情
|
*
|
* @param orderId 订单id
|
* @param prizeName 奖品名称
|
*/
|
@ApiOperation(value = "补充订单津贴金额", tags = {"后台-订单管理"})
|
@GetMapping(value = "/supplementAllowance")
|
public R<Boolean> supplementAllowance(@RequestParam("orderId") String orderId,
|
@RequestParam("prizeName") String prizeName) {
|
BigDecimal bigDecimal;
|
try {
|
bigDecimal = new BigDecimal(prizeName);
|
} catch (Exception e) {
|
bigDecimal = BigDecimal.ZERO;
|
}
|
Order order = orderService.lambdaQuery()
|
.eq(Order::getId, orderId).eq(Order::getIsDelete, 0).one();
|
BigDecimal subsidy = order.getSubsidy();
|
if (null == subsidy) {
|
order.setSubsidy(bigDecimal);
|
order.setOrderMoney(order.getOrderMoney().add(bigDecimal));
|
} else {
|
BigDecimal add = order.getSubsidy().add(bigDecimal);
|
order.setSubsidy(add);
|
order.setOrderMoney(order.getOrderMoney().add(bigDecimal));
|
}
|
return R.ok(orderService.updateById(order));
|
}
|
|
/**
|
* 更改订单状态
|
*
|
* @param orderId 订单id
|
* @param state 状态
|
*/
|
@ApiOperation(value = "更改订单状态", tags = {"后台-订单管理"})
|
@GetMapping(value = "/changeOrderState")
|
public R<Boolean> changeOrderState(@RequestParam("orderId") String orderId, @RequestParam("state") Integer state) {
|
return R.ok(orderService.lambdaUpdate()
|
.eq(Order::getId, orderId).eq(Order::getIsDelete, 0)
|
.set(Order::getState, state).update());
|
}
|
|
/**
|
* 站点详情
|
*
|
* @param id 站点id
|
*/
|
@ApiOperation(value = "订单列表-订单详情", tags = {"后台-订单管理"})
|
@GetMapping(value = "/detail")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "站点id", name = "id", dataType = "String", required = true)
|
})
|
public R<Order> detail(@RequestParam("id") String id) {
|
return R.ok(orderService.lambdaQuery()
|
.eq(Order::getId, id).eq(Order::getIsDelete, 0).one());
|
}
|
|
/**
|
* 申请改派审核通过后生成新订单
|
*
|
* @param order 订单信息
|
*/
|
@GetMapping(value = "/generateNewOrder")
|
public R<Boolean> generateNewOrder(@RequestBody Order order) {
|
return R.ok(orderService.save(order));
|
}
|
|
@PostMapping(value = "/queryIdsBycode")
|
public R<List<Integer>> queryIdsBycode(@RequestBody List<String> cityList) {
|
List<Integer> collect = orderService.lambdaQuery().eq(BaseEntity::getIsDelete,0).in(Order::getCityCode, cityList).list().stream().map(Order::getUserId).collect(Collectors.toList());
|
return R.ok(collect);
|
}
|
|
|
/**
|
* 更改订单信息
|
*
|
* @param type 1:订单派单；2:订单改派
|
*/
|
@GetMapping(value = "/exchangeOrder")
|
public R<Order> exchangeOrder(@RequestParam("type") Integer type, @RequestParam("orderId") String orderId,
|
@RequestParam("workerId") Integer workerId, @RequestParam("name") String name,
|
@RequestParam("phone") String phone) {
|
Order order = orderService.getById(orderId);
|
// 订单派单
|
if (Constants.ONE.equals(type)) {
|
order.setServerId(workerId);
|
order.setServerName(name);
|
order.setServerPhone(phone);
|
order.setAcceptTime(new Date());
|
order.setState(Constants.ONE);
|
orderService.updateById(order);
|
} else if (Constants.TWO.equals(type)) {
|
order.setServerId(workerId);
|
// 更新接单时间
|
order.setAcceptTime(new Date());
|
order.setServerName(name);
|
order.setServerPhone(phone);
|
orderService.updateById(order);
|
}
|
return R.ok(order);
|
}
|
|
@Resource
|
private UserClient userClient;
|
/**
|
* 新增订单
|
* 后台订单为指定订单，默认为待上门状态
|
*
|
* @param orderRequest 订单信息
|
*/
|
@ApiOperation(value = "订单列表-新增订单", tags = {"后台-订单管理"})
|
@PostMapping(value = "/save")
|
public R<Boolean> save(@RequestBody OrderRequest orderRequest) {
|
|
R<BigDecimal> servePrice = userClient.getServePrice(orderRequest.getServeId(), orderRequest.getCityCode());
|
if (servePrice.getData()!=null){
|
orderRequest.setOrderMoney(servePrice.getData());
|
}
|
|
|
|
Order order = new Order();
|
order.setCity(orderRequest.getCity());
|
order.setOrderNumber(orderRequest.getOrderNumber());
|
order.setUserId(orderRequest.getUserId());
|
order.setSiteId(orderRequest.getSiteId());
|
order.setSiteName(orderRequest.getSiteName());
|
order.setServeId(orderRequest.getServeId());
|
order.setServeName(orderRequest.getServeName());
|
order.setServePrice(orderRequest.getOrderMoney());
|
order.setSiteName(orderRequest.getSiteName());
|
// 预约信息
|
order.setReservationName(orderRequest.getReservationName());
|
order.setReservationPhone(orderRequest.getReservationPhone());
|
order.setReservationAddress(orderRequest.getReservationAddress());
|
|
order.setTime(orderRequest.getTime());
|
order.setAcceptTime(orderRequest.getAcceptTime());
|
// 师傅信息
|
order.setServerId(orderRequest.getServerId());
|
order.setServerName(orderRequest.getServerName());
|
order.setServerPhone(orderRequest.getServerPhone());
|
order.setReservationRemark(orderRequest.getReservationRemark());
|
order.setState(orderRequest.getState());
|
order.setArriveTime(orderRequest.getArriveTime());
|
order.setType(orderRequest.getType());
|
order.setLongitude(orderRequest.getLongitude());
|
order.setLatitude(orderRequest.getLatitude());
|
order.setCompleteTime(orderRequest.getCompleteTime());
|
order.setSubsidy(orderRequest.getSubsidy());
|
order.setIsWithdrawal(orderRequest.getIsWithdrawal());
|
order.setAddress(orderRequest.getAddress());
|
order.setCancelReason(orderRequest.getCancelReason());
|
order.setApplyReason(orderRequest.getApplyReason());
|
order.setIsEvaluate(Constants.ZERO);
|
order.setCityCode(orderRequest.getCityCode());
|
order.setOrderMoney(orderRequest.getOrderMoney());
|
order.setProvinceCode(orderRequest.getProvinceCode());
|
order.setAreaCode(orderRequest.getAreaCode());
|
return R.ok(orderService.save(order));
|
}
|
|
|
@ApiOperation(value = "订单列表-新增订单", tags = {"后台-订单管理"})
|
@PostMapping(value = "/edit")
|
public R<Boolean> edit(@RequestBody OrderRequest orderRequest) {
|
|
R<BigDecimal> servePrice = userClient.getServePrice(orderRequest.getServeId(), orderRequest.getCityCode());
|
if (servePrice.getData()!=null){
|
orderRequest.setOrderMoney(servePrice.getData());
|
}
|
|
|
Order order = orderService.getById(orderRequest.getOrderId());
|
if (order.getState()!=6) {
|
if ((!Objects.equals(order.getServerId(), orderRequest.getServerId())) || (!Objects.equals(order.getTime(), orderRequest.getTime()))) {
|
order.setState(1);
|
order.setArriveTime(null);
|
order.setAcceptTime(new Date());
|
orderService.lambdaUpdate()
|
.eq(Order::getId, order.getId()
|
).set(Order::getArriveTime, null).update();
|
|
}
|
}
|
|
order.setId(orderRequest.getOrderId());
|
order.setCity(orderRequest.getCity());
|
order.setOrderNumber(orderRequest.getOrderNumber());
|
order.setUserId(orderRequest.getUserId());
|
order.setSiteId(orderRequest.getSiteId());
|
order.setSiteName(orderRequest.getSiteName());
|
order.setServeId(orderRequest.getServeId());
|
order.setServeName(orderRequest.getServeName());
|
order.setServePrice(orderRequest.getOrderMoney());
|
order.setSiteName(orderRequest.getSiteName());
|
order.setTime(orderRequest.getTime());
|
// 预约信息
|
order.setReservationName(orderRequest.getReservationName());
|
order.setReservationPhone(orderRequest.getReservationPhone());
|
order.setReservationAddress(orderRequest.getReservationAddress());
|
// order.setTime(orderRequest.getTime());
|
// order.setAcceptTime(orderRequest.getAcceptTime());
|
// 师傅信息
|
order.setServerId(orderRequest.getServerId());
|
order.setServerName(orderRequest.getServerName());
|
order.setServerPhone(orderRequest.getServerPhone());
|
order.setReservationRemark(orderRequest.getReservationRemark());
|
|
order.setArriveTime(orderRequest.getArriveTime());
|
// order.setType(orderRequest.getType());
|
order.setLongitude(orderRequest.getLongitude());
|
order.setLatitude(orderRequest.getLatitude());
|
order.setCompleteTime(orderRequest.getCompleteTime());
|
// order.setSubsidy(orderRequest.getSubsidy());
|
order.setIsWithdrawal(orderRequest.getIsWithdrawal());
|
order.setAddress(orderRequest.getAddress());
|
order.setCancelReason(orderRequest.getCancelReason());
|
order.setApplyReason(orderRequest.getApplyReason());
|
order.setIsEvaluate(Constants.ZERO);
|
order.setCityCode(orderRequest.getCityCode());
|
order.setOrderMoney(orderRequest.getServePrice());
|
if (order.getSubsidy()!=null){
|
order.setOrderMoney(order.getServePrice().add(order.getSubsidy()));
|
}
|
order.setProvinceCode(orderRequest.getProvinceCode());
|
order.setAreaCode(orderRequest.getAreaCode());
|
return R.ok(orderService.updateById(order));
|
}
|
|
|
/**
|
* 根据id批量删除站点
|
*
|
* @param ids 站点多条id拼接
|
*/
|
@ApiOperation(value = "订单列表-批量删除订单", tags = {"后台-订单管理"})
|
@GetMapping(value = "/batchDelete")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "多个id ',' 拼接", name = "ids", dataType = "String", required = true)
|
})
|
public R<Boolean> batchDelete(@RequestParam("ids") 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 R.ok(orderService.updateBatchById(list));
|
}
|
|
/**
|
* 订单列表-excel导出
|
*
|
* @param orderQueryRequest 筛选参数
|
*/
|
@ApiOperation(value = "订单列表-excel导出", tags = {"后台-订单管理"})
|
@PostMapping(value = "/excelExport")
|
public R<List<Order>> excelExport(@RequestBody OrderQueryRequest orderQueryRequest) {
|
return R.ok(orderService.excelExport(orderQueryRequest));
|
}
|
|
/**
|
* 订单统计
|
*
|
* @param request 查询参数
|
*/
|
@ApiOperation(value = "订单统计", tags = {"后台-订单管理"})
|
@PostMapping(value = "/orderCount")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "师傅姓名", name = "name", dataType = "String"),
|
@ApiImplicitParam(value = "师傅电话", name = "phone", dataType = "String"),
|
@ApiImplicitParam(value = "页码", name = "pageNum", dataType = "Integer", required = true),
|
@ApiImplicitParam(value = "每页条数", name = "pageSize", dataType = "Integer", required = true)
|
})
|
public R<Page<OrderCountVO>> orderCount(@RequestBody OrderCountDataRequest request) {
|
return R.ok(orderService.orderCount(request.getWorkerName(), request.getWorkerPhone(), request.getCityList(),
|
Page.of(request.getPageNum(), request.getPageSize())));
|
}
|
|
/**
|
* 判断用户是否下单
|
*
|
* @param userId 用户id
|
*/
|
@GetMapping(value = "/orderByUserId")
|
public R<Boolean> orderByUserId(@RequestParam("userId") Integer userId) {
|
List<Order> list = orderService.lambdaQuery()
|
.eq(Order::getUserId, userId)
|
.eq(Order::getIsDelete, Constants.ZERO).list();
|
return R.ok(!list.isEmpty());
|
}
|
|
/**
|
* 回收订单统计
|
*
|
* @param orderCount 查询所需参数
|
*/
|
@ApiOperation(value = "后台-回收订单统计", tags = {"后台-首页"})
|
@PostMapping(value = "/orderCountHome")
|
public R<OrderResultVO> orderCountHome(@RequestBody OrderCountRequest orderCount) {
|
return R.ok(orderService.orderCountHome(orderCount));
|
}
|
|
//获取师傅当天的订单
|
@PostMapping(value = "/workday")
|
public R<List<Order>> workday(@RequestBody Integer workId) {
|
// 获取当前日期
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
|
// 使用 format 方法将 LocalDate 对象转换为字符串
|
String formattedToday = LocalDate.now().format(formatter);
|
|
System.out.println(formattedToday); // 输出：2023-09-12（假设今天是2023年9月12日）
|
|
|
// 构建 Lambda 查询条件
|
LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper
|
.eq(Order::getTime, formattedToday) // 当天开始时间
|
; // 当天结束时间
|
|
// 执行查询
|
List<Order> orders = orderService.list(queryWrapper.eq(Order::getServerId,workId));
|
|
// 处理查询结果
|
for (Order order : orders) {
|
System.out.println(order);
|
}
|
return R.ok(orders);
|
}
|
/**
|
* 用户所关联订单记录分页列表
|
*
|
* @param userId 手机号
|
* @param pageNum 页码
|
* @param pageSize 每页显示条数
|
* @return 分页列表
|
*/
|
@ApiOperation(value = "用户详情-订单记录分页列表", tags = {"后台-用户管理-用户列表"})
|
@GetMapping(value = "/orderList")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "用户id", name = "userId", dataType = "Integer", required = true),
|
@ApiImplicitParam(value = "页码", name = "pageNum", dataType = "Integer", required = true),
|
@ApiImplicitParam(value = "每页条数", name = "pageSize", dataType = "Integer", required = true)
|
})
|
public R<Page<Order>> orderList(@RequestParam("userId") Integer userId,
|
@RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
|
Page<Order> page = orderService.lambdaQuery().eq(Order::getUserId, userId)
|
.eq(Order::getIsDelete, 0).page(Page.of(pageNum, pageSize));
|
return R.ok(page);
|
}
|
|
@GetMapping(value = "/orderList1")
|
public R<Page<Order>> orderList1(@RequestParam("userId") Integer userId, @RequestParam("cityList") List<String> cityList,
|
@RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
|
Page<Order> page = orderService.lambdaQuery().eq(Order::getUserId, userId)
|
.eq(Order::getIsDelete, 0).in(!cityList.isEmpty(),Order::getCityCode, cityList).page(Page.of(pageNum, pageSize));
|
return R.ok(page);
|
}
|
|
@GetMapping(value = "/workOrderList")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "师傅id", name = "workId", dataType = "Integer", required = true),
|
@ApiImplicitParam(value = "页码", name = "pageNum", dataType = "Integer", required = true),
|
@ApiImplicitParam(value = "每页条数", name = "pageSize", dataType = "Integer", required = true)
|
})
|
public R<Page<Order>> workOrderList(@RequestParam("workId") Integer workId,
|
@RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
|
Page<Order> page = orderService.lambdaQuery().eq(Order::getServerId, workId)
|
.eq(Order::getIsDelete, 0).page(Page.of(pageNum, pageSize));
|
return R.ok(page);
|
}
|
|
/**
|
* 根据类型获取交易额
|
*
|
* @param moneyQueryRequest 筛选参数
|
* @return 交易额
|
*/
|
@ApiOperation(value = "根据类型获取交易额", tags = {"后台-用户管理-用户列表"})
|
@PostMapping (value = "/tradeMoney")
|
public R<BigDecimal> tradeMoney(@RequestBody MoneyQueryRequest moneyQueryRequest) {
|
return R.ok(orderService.tradeMoney(moneyQueryRequest));
|
}
|
|
/**
|
* 师傅端-订单列表
|
*
|
* @param userId 用户端
|
* @param state 订单状态
|
* @return 交易额
|
*/
|
@ApiOperation(value = "师傅端-订单列表", tags = {"师傅端"})
|
@GetMapping(value = "/orderListWorker")
|
public R<Page<Order>> orderListWorker(@RequestParam("userId") Integer userId, @RequestParam("state") Integer state,
|
@RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
|
return R.ok(orderService.orderListWorker(userId, state, pageNum, pageSize));
|
}
|
|
/**
|
* 师傅端-根据师傅id获取订单数量
|
*
|
* @param workerIds 师傅id集合
|
* @return 接单列表
|
*/
|
@ApiOperation(value = "根据师傅id获取订单数量", tags = {"师傅端"})
|
@PostMapping(value = "/workerOrderRank")
|
public R<List<WorkerOrderRankVO>> workerOrderRank(@RequestBody List<Integer> workerIds) {
|
return R.ok(orderService.workerOrderRank(workerIds));
|
}
|
|
/**
|
* 师傅端-订单路线导航
|
*
|
* @param orderId 订单id
|
*/
|
@ApiOperation(value = "订单路线导航", tags = {"师傅端"})
|
@GetMapping(value = "/orderNavigation")
|
public R<Path> orderNavigation(@RequestParam("orderId") String orderId, @RequestParam("workerId") Integer workerId,
|
@RequestParam("longitude") String longitude, @RequestParam("latitude") String latitude) {
|
Order order = orderService.lambdaQuery().eq(Order::getId, orderId)
|
.eq(Order::getServerId, workerId)
|
.eq(Order::getIsDelete, 0).one();
|
if (null == order) {
|
throw new GlobalException("请确认当前订单所派单师傅是否是您！");
|
}
|
// 用户下单经纬度
|
Double userLongitude = order.getLongitude();
|
Double userLatitude = order.getLatitude();
|
String userPosition = userLongitude + "," + userLatitude;
|
// 师傅当前位置 经纬度
|
String workerPosition = longitude + "," + latitude;
|
return R.ok(orderService.orderNavigation(userPosition, workerPosition));
|
}
|
|
/**
|
* 师傅端-已到达预约地点
|
*
|
* @param orderId 订单id
|
*/
|
@ApiOperation(value = "已到达预约地点", tags = {"师傅端"})
|
@GetMapping(value = "/reachPosition")
|
public R<Boolean> reachPosition(@RequestParam("orderId") String orderId, @RequestParam("workerId") Integer workerId) {
|
Order order = orderService.lambdaQuery().eq(Order::getId, orderId).eq(Order::getServerId, workerId)
|
.eq(Order::getIsDelete, 0).one();
|
if (null == order) {
|
throw new GlobalException("请确认当前订单所派单师傅是否是您！");
|
}
|
// 待完工状态
|
order.setState(Constants.TWO);
|
order.setArriveTime(new Date());
|
return R.ok(orderService.updateById(order));
|
}
|
|
/**
|
* 师傅端-订单详情
|
*
|
* @param orderId 订单id
|
*/
|
@ApiOperation(value = "订单详情", tags = {"师傅端-订单列表"})
|
@GetMapping(value = "/orderDetail")
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "订单id", name = "orderId", dataType = "String", required = true)
|
})
|
public R<OrderDetailVO> orderDetail(@RequestParam("orderId") String orderId) {
|
// 订单信息
|
Order order = orderService.lambdaQuery().eq(Order::getId, orderId).eq(Order::getIsDelete, 0).one();
|
if (order.getAddress()!=null) {
|
order.setReservationAddress(order.getReservationAddress() + order.getAddress());
|
}
|
// 服务信息(服务备注、上门时间、完成时间、完成所拍现场照片)
|
ServeRecord serveRecord = serveRecordService.lambdaQuery().eq(ServeRecord::getOrderId, orderId)
|
.eq(ServeRecord::getIsDelete, 0).one();
|
// 评价信息
|
Evaluate evaluate = evaluateService.lambdaQuery().eq(Evaluate::getOrderId, orderId)
|
.eq(Evaluate::getIsDelete, 0).one();
|
return R.ok(new OrderDetailVO(order, serveRecord, evaluate));
|
}
|
|
/**
|
* 师傅端-订单详情
|
*
|
* @param orderSubmitRequest 提交订单信息
|
*/
|
@ApiOperation(value = "订单完工-提交订单", tags = {"师傅端-订单列表"})
|
@PostMapping(value = "/orderSubmit")
|
@Transactional(rollbackFor = Exception.class)
|
public R<Boolean> orderSubmit(@RequestBody OrderSubmitRequest orderSubmitRequest) {
|
// 订单信息
|
Order order = orderService.lambdaQuery().eq(Order::getId, orderSubmitRequest.getOrderId())
|
.eq(Order::getIsDelete, 0).one();
|
// 订单不存在，或订单状态异常(订单状态为2才可提交)
|
if (null == order || !Constants.TWO.equals(order.getState())) {
|
throw new GlobalException("订单不存在或订单状态异常！");
|
}
|
order.setCompleteTime(new Date());
|
order.setState(Constants.THREE);
|
order.setFake(orderSubmitRequest.getFake());
|
boolean update = orderService.updateById(order);
|
// 服务记录
|
ServeRecord serveRecord = new ServeRecord();
|
serveRecord.setOrderId(order.getId());
|
serveRecord.setPhoto(String.join(",", orderSubmitRequest.getPhoto()));
|
serveRecord.setPaperPic(orderSubmitRequest.getPaperPic());
|
serveRecord.setCardPic(orderSubmitRequest.getCardPic());
|
serveRecord.setMachinePic(orderSubmitRequest.getMachinePic());
|
boolean save = serveRecordService.save(serveRecord);
|
return R.ok(update && save);
|
}
|
|
/**
|
* 师傅端-定时调度记录师傅所走路线经纬度
|
*
|
* @param orderId 订单id
|
* @param longitude 经度
|
* @param latitude 纬度
|
*/
|
@ApiOperation(value = "订单进行-记录路线经纬度", tags = {"师傅端"})
|
@GetMapping(value = "/coordinate")
|
@Transactional(rollbackFor = Exception.class)
|
public R<Boolean> coordinate(@RequestParam("orderId") String orderId, @RequestParam("workerId") Integer workerId,
|
@RequestParam("longitude") Double longitude, @RequestParam("latitude") Double latitude) {
|
ServeCoordinate serveCoordinate = new ServeCoordinate();
|
serveCoordinate.setWorkerId(workerId);
|
serveCoordinate.setOrderId(orderId);
|
serveCoordinate.setCoordinate(longitude + "," + latitude);
|
serveCoordinate.setLongitude(BigDecimal.valueOf(longitude));
|
serveCoordinate.setLatitude(BigDecimal.valueOf(latitude));
|
return R.ok(serveCoordinateService.save(serveCoordinate));
|
}
|
|
/**
|
* 师傅端-代办列表
|
*
|
* @param workerId 师傅id
|
*/
|
|
|
// ...
|
|
@ApiOperation(value = "代办列表", tags ={"师傅端"})
|
@GetMapping(value = "/orderNotHandle")
|
public R<List<Order>> orderNotHandle(@RequestParam("workerId") Integer workerId) {
|
// 获取当前日期
|
LocalDate today = LocalDate.now();
|
|
// 格式化日期字符串，假设数据库中的日期格式为 yyyy-MM-dd
|
String todayStr = today.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
|
QueryWrapper<Order> wrapper = new QueryWrapper<>();
|
wrapper.eq("server_id", workerId)
|
.in("state", 1, 2)
|
.eq("is_delete", Constants.ZERO)
|
.eq("DATE(time)", todayStr) // 添加这一行来筛选当天的订单
|
.orderByAsc("CASE WHEN topSort IS NULL THEN 1 ELSE 0 END")
|
.orderByAsc("topSort");
|
|
List<Order> list = orderService.list(wrapper);
|
for (Order order : list) {
|
if (order.getAcceptTime()==null){
|
order.setAcceptTime(order.getCreateTime());
|
}
|
}
|
|
return R.ok(list);
|
}
|
|
|
/**
|
* 师傅端-订单代办列表
|
*/
|
@ApiOperation(value = "订单置顶", tags = {"师傅端-首页"})
|
@GetMapping(value = "/orderTop")
|
public R<Boolean> orderTop(@RequestParam("orderId") String orderId, @RequestParam("workerId") Integer workerId) {
|
return R.ok(orderService.orderTop(orderId, workerId));
|
}
|
|
/**
|
* 师傅端-订单状态统计数量
|
*/
|
@ApiOperation(value = "订单状态统计数量", tags = {"师傅端-首页"})
|
@GetMapping(value = "/orderStateCount")
|
public R<WorkerOrderCountVO> orderStateCount(@RequestParam("workerId") Integer workerId) {
|
return R.ok(orderService.orderStateCount(workerId));
|
}
|
|
/************************************** 用户端远程调用接口 ***************************************/
|
|
/**
|
* 用户端-订单状态统计数量
|
*/
|
@ApiOperation(value = "订单状态统计数量", tags = {"用户端"})
|
@GetMapping(value = "/orderListByUser")
|
public R<Page<Order>> orderListByUser(@RequestParam("userId") Integer userId,
|
@RequestParam("state") Integer state,
|
@RequestParam(name = "pageNum", defaultValue = "1") Integer pageNum,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
|
LambdaQueryChainWrapper<Order> wrapper = orderService.lambdaQuery()
|
.eq(Order::getIsDelete, 0).eq(Order::getUserId, userId);
|
if (state == 1 || state == 2) {
|
wrapper.in(Order::getState, Constants.ONE, Constants.TWO);
|
} else if (state != -1) {
|
wrapper.eq(Order::getState, state);
|
}
|
return R.ok(wrapper.orderByDesc(Order::getCreateTime).page(Page.of(pageNum, pageSize)));
|
}
|
|
/**
|
* 用户端-生成预订单信息
|
*/
|
@ApiOperation(value = "生成预订单信息", tags = {"用户端"})
|
@PostMapping(value = "/orderEstimate")
|
public R<String> orderEstimate(@RequestBody UserOrderRequest userOrderRequest) {
|
return R.ok(orderService.orderEstimate(userOrderRequest), "");
|
}
|
|
/**
|
* 用户端-用户下单
|
*/
|
@ApiOperation(value = "下单", tags = {"用户端"})
|
@PostMapping(value = "/placeOrder")
|
public R<Boolean> placeOrder(@RequestBody UserOrderRequest userOrderRequest) {
|
return R.ok(orderService.placeOrder(userOrderRequest));
|
}
|
|
}
|
