短信发送
短信服务介绍
目前市面上有很多第三方提供的短信服务，这些第三方短信服务会和各个运营商（移动、联通、电信)对接，我们只需要注册成为会员并且按照提供的开发文档进行调用就可以发送短信。需要说明的是，这些短信服务一般都是收费服务。
常用短信服务:阿里云，，华为云，腾讯云，京东，梦网，乐信
阿里云短信服务-介绍
阿里云短信服务（Short Message Service)是广大企业客户快速触达手机用户所优选使用的通信能力。调用API或用群发助手，即可发送验证码、通知类和营销类短信;国内验证短信秒级触达，到达率最高可达99%;国际/港澳台短信覆盖200多个国家和地区，安全稳定，广受出海企业选用。
应用场景:验证码，短信通知，推广短信
阿里云短信服务-注册账号
阿里云官网: https://www.aliyun.com/
阿里云短信服务-设置短信签名与模版
阿里云短信服务-设置AccessKey
代码开发
使用阿里云短信服务发送短信，可以参照官方提供的文档即可。
具体开发步骤:
1、导入maven坐标
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-core</artifactId>
<version>4.5.16</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-dysmsapi</artifactId>
<version>1.1.0</version>
</dependency>
2、调用API
public class SMSUtils {
/**
* 发送短信
* @param signName 签名
* @param templateCode 模板
* @param phoneNumbers 手机号
* @param param 参数
*/
public static void sendMessage(String signName, String templateCode,String phone,String param){
DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "", "");
IAcsClient client = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
request.setPhoneNumbers(phone);
request.setSignName(signName);
request.setTemplateCode(templateCode);
request.setTemplateParam("{\"code\":\""+param+"\"}");
try {
SendSmsResponse response = client.getAcsResponse(request);
System.out.println("短信发送成功");
}catch (ClientException e) {
e.printStackTrace();
}
}
}
手机验证码登录
需求分析
为了方便用户登录，移动端通常都会提供通过手机验证码登录的功能。
手机验证码登录的优点:
. 方便快捷，无需注册，直接登录
. 使用短信验证码作为登录凭证，无需记忆密码
. 安全
登录流程:
输入手机号>获取验证码>输入验证码>点击登录>登录成功
注意:通过手机验证码登录，手机号是区分不同用户的标识。
数据模型
通过手机验证码登录时，涉及的表为user表，即用户表。结构如下:
代码开发
在开发代码之前，需要梳理一下登录时前端页面和服务端的交互过程:
1、在登录页面(front/page/login.html)输入手机号，点击【获取验证码】按钮，页面发送ajax请求，在服务端调用短信服务API给指定手机号发送验证码短信
2、在登录页面输入验证码，点击【登录】按钮，发送ajax请求，在服务端处理登录请求
开发手机验证码登录功能，其实就是在服务端编写代码去处理前端页面发送的这2次请求即可。
在开发业务功能前，先将需要用到的类和接口基本结构创建好:
. 实体类User(直接从课程资料中导入即可)
. Mapper接口UserMapper
. 业务层接口UserService
. 业务层实现类UserServicelmpl
. 控制层UserController
. 工具类SMSutils、 ValidateCodeutils（直接从课程资料中导入即可)
前面我们已经完成了LogincheckFilter过滤器的开发，此过滤器用于检查用户的登录状态。我们在进行手机验证码登录时，发送的请求需要在此过滤器处理时直接放行。
前面我们已经完成了LogincheckFilter过滤器的开发，此过滤器用于检查用户的登录状态。我们在进行手机验证码登录时，发送的请求需要在此过滤器处理时直接放行。
String[] urls=new String[]{
"/backend/**",
"/front/**",
"/employee/login",
"/employee/logout",
"/user/sendMsg", //移动端发送短信
"/user/login" //移动端登录
};
// 4-2、判断登录状态，如果已登录，则直接放行
if(request.getSession().getAttribute("user")!=null){
log.info("用户已登录,用户id为{}",request.getSession().getAttribute("user"));
Long userId = (Long) request.getSession().getAttribute("user");
//通过写的工具类BaseContext,保存id到ThreadLocal中，方便获取。注意：只有一次请求所经历的方法线程才相同
BaseContext.setCurrentId(userId);
filterChain.doFilter(request,response);
return;
}
UserController处理post请求（发送验证码的请求）
@PostMapping("/sendMsg")
public R<String> sendMsg(@RequestBody User user, HttpSession session){
// 获取手机号
String phone = user.getPhone();
if(StringUtils.isNotEmpty(phone)){
// 生成4位验证码
String code = ValidateCodeUtils.generateValidateCode(4).toString();
log.info("code={}",code);
// 调用阿里云提供的短信服务API完成发送短信
// SMSUtils.sendMessage("瑞吉外卖", " ",phone,code);
// 将生成的验证码保存到Session
session.setAttribute(phone,code);
return R.success("手机验证码短信发送成功");
}
return R.error("手机验证码短信发送失败");
}
在UserController编写login处理post请求
@PostMapping("login")
public R<User> login(@RequestBody Map map,HttpSession session){
log.info(map.toString());
// 获取手机号
String phone = map.get("phone").toString();
// 获取验证码
String code = map.get("code").toString();
// 获取Session中的手机号和验证码
Object attribute = session.getAttribute(phone);
// 与session中的验证码比较
if(attribute != null && attribute.equals(code)){
//成功，登录成功，判断手机号是否为新用户，无则自动完成注册
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getPhone,phone);
User user = userService.getOne(queryWrapper);
if(user == null){
user=new User();
user.setPhone(phone);
userService.save(user);
}
session.setAttribute("user",user.getId());
return R.success(user);
}
return R.error("登录失败");
}
用户地址簿开发与实现
需求分析
地址簿，指的是移动端消费者用户的地址信息，用户登录成功后可以维护自己的地址信息。同一个用户可以有多个地址信息，但是只能有一个默认地址。
数据模型
用户的地址信息会存储在address_book表，即地址簿表中。具体表结构如下:
导入功能代码
功能代码清单:
。 实体类AddressBook(直接从课程资料中导入即可)
。 Mapper接口AddressBookMapper
。 业务层接口AddressBookService
。 业务层实现类AddressBookServicelmpl
。 控制层AddressBookController(直接从课程资料中导入即可)
AddressBookController代码实现
package com.ch.reggie.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.ch.reggie.common.BaseContext;
import com.ch.reggie.common.R;
import com.ch.reggie.entity.AddressBook;
import com.ch.reggie.service.AddressBookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@RestController
@RequestMapping("/addressBook")
/**
* 地址簿管理
*/
public class AddressBookController {
@Autowired
private AddressBookService addressBookService;
/**
* 新增地址簿
* @return
*/
@PostMapping
public R<AddressBook> save(@RequestBody AddressBook addressBook){
addressBook.setUserId(BaseContext.getCurrentId()); //自动填充id
log.info(addressBook.toString());
addressBookService.save(addressBook);
return R.success(addressBook);
}
/**
* 设置默认地址
* @return
*/
@PutMapping("/default")
@Transactional
public R<AddressBook> setDefault(@RequestBody AddressBook addressBook){
// 设置默认地址，首先将所有的地址改成非默认，然后将该地址改为默认
LambdaUpdateWrapper<AddressBook> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
wrapper.set(AddressBook::getIsDefault,0);
addressBookService.update(wrapper);
addressBook.setIsDefault(1);
addressBookService.updateById(addressBook);
return R.success(addressBook);
}
/**
* 根据id查询地址
* @return
*/
@GetMapping("/{id}")
public R get(@PathVariable Long id){
AddressBook addressBook = addressBookService.getById(id);
if(addressBook != null){
return R.success(addressBook);
}else {
return R.error("没有该对象");
}
}
/**
* 查询默认地址
*/
@GetMapping("default")
public R<AddressBook> getDefault() {
LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(AddressBook::getUserId, BaseContext.getCurrentId());
queryWrapper.eq(AddressBook::getIsDefault, 1);
//SQL:select * from address_book where user_id = ? and is_default = 1
AddressBook addressBook = addressBookService.getOne(queryWrapper);
if (null == addressBook) {
return R.error("没有找到该对象");
} else {
return R.success(addressBook);
}
}
/**
* 查询指定用户的全部地址
*/
@GetMapping("/list")
public R<List<AddressBook>> list(AddressBook addressBook){
addressBook.setUserId(BaseContext.getCurrentId());
LambdaQueryWrapper<AddressBook> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(addressBook.getUserId()!=null,AddressBook::getUserId,addressBook.getUserId());
queryWrapper.orderByDesc(AddressBook::getUpdateTime);
List<AddressBook> list = addressBookService.list(queryWrapper);
return R.success(list);
}
/**
* 根据id修改地址簿
* @return
*/
@PutMapping
public R<AddressBook> update(@RequestBody AddressBook addressBook){
log.info(addressBook.toString());
addressBookService.updateById(addressBook);
return R.success(addressBook);
}
/**
* 删除地址簿
* @param ids
* @return
*/
@DeleteMapping()
public R<String> delete(Long ids){
addressBookService.removeById(ids);
return R.success("删除成功");
}
}
菜品展示
需求分析
用户登录成功后跳转到系统首页，在首页需要根据分类来展示菜品和套餐。如果菜品设置了口味信息需要展示 [选择规格] 按钮，否则显示 [+] 按钮。
梳理交互过程
在开发代码之前，需要梳理一下购物车操作时前端页面和服务端的交互过程:
1、点击 [加入购物车] 或者 [+] 按钮，页面发送ajax请求，请求服务端，将菜品或者套餐添加到购物车
2、点击购物车图标，页面发送ajax请求，请求服务端查询购物车中的菜品和套餐
3、点击清空购物车按钮，页面发送ajax请求，请求服务端来执行清空购物车操作
开发购物车功能，其实就是在服务端编写代码去处理前端页面发送的这3次请求即可。
改造DishController中的list方法
@GetMapping("/list")
public R<List<DishDto>> list(Dish dish){
//查询条件对象
LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(dish.getCategoryId()!=null,Dish::getCategoryId,dish.getCategoryId());
//只查可以出售的
queryWrapper.eq(Dish::getStatus,1);
//排序条件
queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
List<Dish> list = dishService.list(queryWrapper);
List<DishDto> dishDtoList=
list.stream().map((item)->{
DishDto dishDto = new DishDto();
BeanUtils.copyProperties(item,dishDto);
Long categoryId = item.getCategoryId();
Category category = categoryService.getById(categoryId);
if(category != null){
String categoryName = category.getName();
dishDto.setCategoryName(categoryName);
}
Long dishId = item.getId(); //当前菜品的id
LambdaQueryWrapper<DishFlavor> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(DishFlavor::getDishId,dishId);
List<DishFlavor> dishFlavorList = dishFlavorService.list(lambdaQueryWrapper);
dishDto.setFlavors(dishFlavorList);
return dishDto;
}).collect(Collectors.toList());
return R.success(dishDtoList);
}
在SetmealController里添加list方法显示套餐信息
@GetMapping("/list")
public R<List<Setmeal>> list(Setmeal setmeal){
LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(setmeal.getCategoryId() != null,Setmeal::getCategoryId,setmeal.getCategoryId());
queryWrapper.eq(setmeal.getStatus() != null,Setmeal::getStatus,setmeal.getStatus());
queryWrapper.orderByDesc(Setmeal::getUpdateTime);
List<Setmeal> setmealList = setmealService.list(queryWrapper);
return R.success(setmealList);
}
在SetmealController里添加list方法查询所有菜品信息
@GetMapping("/dish/{id}")
public R<List<Setmeal>> list(@PathVariable Long id){
log.info("套餐id为：{}",id.toString());
LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Setmeal::getId,id);
queryWrapper.orderByDesc(Setmeal::getUpdateTime);
List<Setmeal> setmealList = setmealService.list(queryWrapper);
return R.success(setmealList);
}
购物车
需求分析
移动端用户可以将菜品或者套餐添加到购物车。对于菜品来说，如果设置了口味信息，则需要选择规格后才能加入购物车;对于套餐来说，可以直接点击 [+] 将当前套餐加入购物车。在购物车中可以修改菜品和套餐的数量,也可以清空购物车。
数据模型
购物车对应的数据表为shopping_cart表，具体表结构如下:
梳理交互过程
在开发代码之前，需要梳理一下购物车操作时前端页面和服务端的交互过程:
1、点击 [加入购物车] 或者 [+] 按钮，页面发送ajax请求，请求服务端，将菜品或者套餐添加到购物车
2、点击购物车图标，页面发送ajax请求，请求服务端查询购物车中的菜品和套餐
3、点击清空购物车按钮，页面发送ajax请求，请求服务端来执行清空购物车操作
开发购物车功能，其实就是在服务端编写代码去处理前端页面发送的这3次请求即可。
代码开发-准备工作
。 实体类ShoppingCart(直接从课程资料中导入即可)
。 Mapper接口ShoppingCartMapper
。 业务层接口ShoppingcartService
。 业务层实现类ShoppingCartServicelmpl
。 控制层ShoppingCartController
代码实现
package com.ch.reggie.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ch.reggie.common.BaseContext;
import com.ch.reggie.common.R;
import com.ch.reggie.entity.ShoppingCart;
import com.ch.reggie.service.ShoppingCartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
@RestController
@RequestMapping("/shoppingCart")
@Slf4j
public class ShoppingCartController {
@Autowired
private ShoppingCartService shoppingCartService;
/**
* 添加购物车
* @param shoppingCart
* @return
*/
@PostMapping("/add")
public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart){
shoppingCart.setUserId(BaseContext.getCurrentId()); //设置用户id
// 查询当前菜品或套餐是否在购物车中。
Long dishId = shoppingCart.getDishId();
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,shoppingCart.getUserId());
if(dishId != null){
//添加到购物车的是菜品
queryWrapper.eq(ShoppingCart::getDishId,dishId);
}else {
//添加到购物车的是套餐
queryWrapper.eq(ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
}
//SQL:select *from shopping_cart where user_id=? and dish_id/setmeal_id =?
ShoppingCart shoppingCartServiceOne = shoppingCartService.getOne(queryWrapper);
if(shoppingCartServiceOne != null){
// 有则数量加一。
Integer number = shoppingCartServiceOne.getNumber();
shoppingCartServiceOne.setNumber(number+1);
shoppingCartService.updateById(shoppingCartServiceOne);
}else {
// 无则添加到购物车，数量默认为一
shoppingCart.setNumber(1);
shoppingCart.setCreateTime(LocalDateTime.now());
shoppingCartService.save(shoppingCart);
shoppingCartServiceOne=shoppingCart;
}
return R.success(shoppingCartServiceOne);
}
/**
* 查看购物车
* @return
*/
@GetMapping({"/list"})
public R<List<ShoppingCart>> list(){
log.info("查看购物车。。。");
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,BaseContext.getCurrentId());
queryWrapper.orderByAsc(ShoppingCart::getCreateTime);
List<ShoppingCart> shoppingCartList = shoppingCartService.list(queryWrapper);
return R.success(shoppingCartList);
}
/**
* 清空购物车
* @return
*/
@DeleteMapping("/clean")
public R<String> clean(){
Long currentId = BaseContext.getCurrentId();
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,BaseContext.getCurrentId());
shoppingCartService.remove(queryWrapper);
return R.success("已清空购物车");
}
/**
* 购物车减
* @return
*/
@PostMapping("/sub")
public R<ShoppingCart> sub(@RequestBody ShoppingCart shoppingCart){
log.info("要减的为{}",shoppingCart.toString());
// 判断菜品/套餐
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,BaseContext.getCurrentId());
if(shoppingCart.getDishId() != null){
//菜品
queryWrapper.eq(ShoppingCart::getDishId,shoppingCart.getDishId());
}else {
//套餐
queryWrapper.eq(ShoppingCart::getSetmealId,shoppingCart.getSetmealId());
}
List<ShoppingCart> shoppingCartList = shoppingCartService.list(queryWrapper);
for (ShoppingCart cart : shoppingCartList) {
Integer number = cart.getNumber();
number--;
if(number<=0){
// 删除
shoppingCartService.removeById(cart);
}else {
cart.setNumber(number);
shoppingCartService.updateById(cart);
}
}
return R.success(shoppingCart);
}
}
下单
需求分析
移动端用户将菜品或者套餐加入购物车后，可以点击购物车中的 【去结算】 按钮，页面跳转到订单确认页面，点击 【去支付】 按钮则完成下单操作。
数据模型
用户下单业务对应的数据表为orders表和order_detail表:
orders
order_detail
梳理交互过程
在开发代码之前，需要梳理一下用户下单操作时前端页面和服务端的交互过程:
1、在购物车中点击 【去结算】 按钮，页面跳转到订单确认页面
2、在订单确认页面，发送ajax请求，请求服务端获取当前登录用户的默认地址
3、在订单确认页面，发送ajax请求，请求服务端获取当前登录用户的购物车数据
4、在订单确认页面点击 【去支付】 按钮，发送ajax请求，请求服务端完成下单操作
开发用户下单功能，其实就是在服务端编写代码去处理前端页面发送的请求即可。
代码开发-准备工作
在开发业务功能前，先将需要用到的类和接口基本结构创建好:
. 实体类Orders、OrderDetail（直接从课程资料中导入即可)
. Mapper接口OrderMapper、OrderDetailMapper
. 业务层接口OrderService、OrderDetailService
. 业务层实现类OrderServicelmpl、OrderDetailServicelmpl
. 控制层OrderController、OrderDetailController
代码实现
package com.ch.reggie.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ch.reggie.common.BaseContext;
import com.ch.reggie.common.CustomException;
import com.ch.reggie.entity.*;
import com.ch.reggie.mapper.OrderMapper;
import com.ch.reggie.service.*;
import com.ch.reggie.service.AddressBookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.jws.soap.SOAPBinding;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper,Orders> implements OrderService {
/**
* 用户下单
* 1、获取当前用户id
* 2、查询当前用户的购物车数据 (有购物信息)
* 查询用户数据
* 查询地址数据
* 3、订单表插入一条数据
* 4、订单明细表插入 多条/一条 数据
* 5、清空购物车数据
* @param orders
*/
@Autowired
private ShoppingCartService shoppingCartService;
@Autowired
private UserService userService;
@Autowired
private AddressBookService addressBookService;
@Autowired
private OrderDetailService orderDetailService;
@Override
@Transactional
public void submit(Orders orders) {
//1、获取当前用户id
Long UserId = BaseContext.getCurrentId();
//2、查询当前用户的购物车数据
LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShoppingCart::getUserId,UserId);
List<ShoppingCart> shoppingCartList = shoppingCartService.list(queryWrapper);
if (shoppingCartList == null || shoppingCartList.size()==0){
throw new CustomException("购物车为空，不能下单");
}
//查询用户数据
User user = userService.getById(UserId);
//查询地址数据
Long addressBookId = orders.getAddressBookId();
AddressBook addressBook = addressBookService.getById(addressBookId);
if (addressBook == null){
throw new CustomException("地址信息有误，不能下单");
}
long orderId = IdWorker.getId(); //订单号
//计算总金额，订单明细
AtomicInteger amount = new AtomicInteger(0);
List<OrderDetail> orderDetails = shoppingCartList.stream().map((item)->{
OrderDetail orderDetail = new OrderDetail();
orderDetail.setOrderId(orderId);
orderDetail.setNumber(item.getNumber());
orderDetail.setDishFlavor(item.getDishFlavor());
orderDetail.setDishId(item.getDishId());
orderDetail.setSetmealId(item.getSetmealId());
orderDetail.setName(item.getName());
orderDetail.setImage(item.getImage());
orderDetail.setAmount(item.getAmount());
amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
return orderDetail;
}).collect(Collectors.toList());
//3、订单表插入一条数据
orders.setId(orderId);
orders.setOrderTime(LocalDateTime.now());
orders.setCheckoutTime(LocalDateTime.now());
orders.setStatus(2);
orders.setAmount(new BigDecimal(amount.get())); //金额
orders.setUserId(UserId);
orders.setNumber(String.valueOf(orderId));
orders.setUserName(user.getName());
orders.setConsignee(addressBook.getConsignee());
orders.setPhone(addressBook.getPhone());
orders.setAddress((addressBook.getProvinceName() == null ? "":addressBook.getProvinceName())
+(addressBook.getDistrictName() == null ? "":addressBook.getDistrictName())
+(addressBook.getDetail() == null ? "":addressBook.getDetail()));
this.save(orders);
//4、订单明细表插入 多条/一条 数据
orderDetailService.saveBatch(orderDetails);
// 5、清空购物车数据
shoppingCartService.remove(queryWrapper);
}
}
功能补充
订单管理
//订单管理
@Transactional
@GetMapping("/userPage")
public R<Page> userPage(int page, int pageSize){
//构造分页构造器
Page<Orders> pageInfo = new Page<>(page, pageSize);
Page<OrdersDto> ordersDtoPage = new Page<>();
//构造条件构造器
LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
//添加排序条件
queryWrapper.orderByDesc(Orders::getOrderTime);
//进行分页查询
orderService.page(pageInfo,queryWrapper);
//对象拷贝
BeanUtils.copyProperties(pageInfo,ordersDtoPage,"records");
List<Orders> records=pageInfo.getRecords();
List<OrdersDto> list = records.stream().map((item) -> {
OrdersDto ordersDto = new OrdersDto();
BeanUtils.copyProperties(item, ordersDto);
Long Id = item.getId();
//根据id查分类对象
Orders orders = orderService.getById(Id);
String number = orders.getNumber();
LambdaQueryWrapper<OrderDetail> lambdaQueryWrapper=new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(OrderDetail::getOrderId,number);
List<OrderDetail> orderDetailList = orderDetailService.list(lambdaQueryWrapper);
int num=0;
for(OrderDetail l:orderDetailList){
num+=l.getNumber().intValue();
}
ordersDto.setSumNum(num);
return ordersDto;
}).collect(Collectors.toList());
ordersDtoPage.setRecords(list);
return R.success(ordersDtoPage);
}
再来一单
//再来一单
@Transactional
@PostMapping("/again")
public R<String> again(@RequestBody Orders order1){
//取得orderId
Long id = order1.getId();
Orders orders = orderService.getById(id);
//设置订单号码
long orderId = IdWorker.getId();
orders.setId(orderId);
//设置订单号码
String number = String.valueOf(IdWorker.getId());
orders.setNumber(number);
//设置下单时间
orders.setOrderTime(LocalDateTime.now());
orders.setCheckoutTime(LocalDateTime.now());
orders.setStatus(2);
//向订单表中插入一条数据
orderService.save(orders);
//修改订单明细表
LambdaQueryWrapper<OrderDetail> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(OrderDetail::getOrderId,id);
List<OrderDetail> list = orderDetailService.list(queryWrapper);
list.stream().map((item)->{
//订单明细表id
long detailId = IdWorker.getId();
//设置订单号码
item.setOrderId(orderId);
item.setId(detailId);
return item;
}).collect(Collectors.toList());
//向订单明细表中插入多条数据
orderDetailService.saveBatch(list);
return R.success("再来一单");
}
管理端订单明细
//管理端订单明细
@GetMapping("/page")
public R<Page> page(int page, int pageSize, String number,String beginTime,String endTime){
//构造分页构造器
Page<Orders> pageInfo = new Page<>(page, pageSize);
Page<OrdersDto> ordersDtoPage=new Page<>();
//构造条件构造器
LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
//根据number进行模糊查询
queryWrapper.like(!StringUtils.isEmpty(number),Orders::getNumber,number);
//根据Datetime进行时间范围查询
// log.info("开始时间：{}",beginTime);
// log.info("结束时间：{}",endTime);
if(beginTime!=null&&endTime!=null){
queryWrapper.ge(Orders::getOrderTime,beginTime);
queryWrapper.le(Orders::getOrderTime,endTime);
}
//添加排序条件
queryWrapper.orderByDesc(Orders::getOrderTime);
//进行分页查询
orderService.page(pageInfo,queryWrapper);
//对象拷贝
BeanUtils.copyProperties(pageInfo,ordersDtoPage,"records");
List<Orders> records=pageInfo.getRecords();
List<OrdersDto> list=records.stream().map((item)->{
OrdersDto ordersDto=new OrdersDto();
BeanUtils.copyProperties(item,ordersDto);
String name="用户"+item.getUserId();
ordersDto.setUserName(name);
return ordersDto;
}).collect(Collectors.toList());
ordersDtoPage.setRecords(list);
return R.success(ordersDtoPage);
}
外卖订单派送
@PutMapping
public R<String> send(@RequestBody Orders orders){
Long id = orders.getId();
Integer status = orders.getStatus();
LambdaQueryWrapper<Orders> queryWrapper=new LambdaQueryWrapper<>();
queryWrapper.eq(Orders::getId,id);
Orders one = orderService.getOne(queryWrapper);
one.setStatus(status);
orderService.updateById(one);
return R.success("派送成功");
}
用户登出
//用户登出
@PostMapping("/loginout")
public R<String> loginout(HttpServletRequest request){
//清理Session中保存的当前用户登录的id
request.getSession().removeAttribute("user");
return R.success("退出成功");
}
扫一扫
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
