Merge branch 'main' into dev

sky-server/src/main/java/com/sky/controller/admin/CategoryController.java

@@ -0,0 +1,116 @@
+package com.sky.controller.admin;
+
+import com.sky.dto.CategoryDTO;
+import com.sky.dto.CategoryPageQueryDTO;
+import com.sky.entity.Category;
+import com.sky.result.PageResult;
+import com.sky.result.Result;
+import com.sky.service.CategoryService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+/**
+ * 分类管理控制器
+ * 提供了分类的增、删、改、查以及启用禁用等操作接口。
+ */
+@RestController
+@RequestMapping("/admin/category") // 设置路由前缀
+@Api(tags = "分类相关接口") // Swagger注解，用于生成API文档
+@Slf4j // 日志注解，简化日志处理
+public class CategoryController {
+
+    @Autowired
+    private CategoryService categoryService; // 注入分类服务对象
+
+    /**
+     * 新增分类
+     * 接收分类数据对象并调用服务层保存数据。
+     *
+     * @param categoryDTO 分类数据传输对象
+     * @return 成功提示信息
+     */
+    @PostMapping
+    @ApiOperation("新增分类") // Swagger注解，标注接口功能
+    public Result<String> save(@RequestBody CategoryDTO categoryDTO) {
+        log.info("新增分类：{}", categoryDTO); // 打印日志
+        categoryService.save(categoryDTO); // 调用服务层方法保存分类
+        return Result.success(); // 返回成功响应
+    }
+
+    /**
+     * 分页查询分类
+     * 支持根据分页条件查询分类列表。
+     *
+     * @param categoryPageQueryDTO 分页查询条件数据传输对象
+     * @return 分页结果
+     */
+    @GetMapping("/page")
+    @ApiOperation("分类分页查询")
+    public Result<PageResult> page(CategoryPageQueryDTO categoryPageQueryDTO) {
+        log.info("分页查询：{}", categoryPageQueryDTO); // 打印日志
+        PageResult pageResult = categoryService.pageQuery(categoryPageQueryDTO); // 查询分页结果
+        return Result.success(pageResult); // 返回分页结果
+    }
+
+    /**
+     * 删除分类
+     * 根据分类ID删除分类数据。
+     *
+     * @param id 分类ID
+     * @return 成功提示信息
+     */
+    @DeleteMapping
+    @ApiOperation("删除分类")
+    public Result<String> deleteById(Long id) {
+        log.info("删除分类：{}", id); // 打印日志
+        categoryService.deleteById(id); // 调用服务层方法删除分类
+        return Result.success(); // 返回成功响应
+    }
+
+    /**
+     * 修改分类
+     * 更新指定分类的信息。
+     *
+     * @param categoryDTO 分类数据传输对象
+     * @return 成功提示信息
+     */
+    @PutMapping
+    @ApiOperation("修改分类")
+    public Result<String> update(@RequestBody CategoryDTO categoryDTO) {
+        categoryService.update(categoryDTO); // 调用服务层方法更新分类
+        return Result.success(); // 返回成功响应
+    }
+
+    /**
+     * 启用或禁用分类
+     * 根据状态启用或禁用分类。
+     *
+     * @param status 分类状态，1为启用，0为禁用
+     * @param id 分类ID
+     * @return 成功提示信息
+     */
+    @PostMapping("/status/{status}")
+    @ApiOperation("启用禁用分类")
+    public Result<String> startOrStop(@PathVariable("status") Integer status, Long id) {
+        categoryService.startOrStop(status, id); // 调用服务层方法启用/禁用分类
+        return Result.success(); // 返回成功响应
+    }
+
+    /**
+     * 根据类型查询分类
+     * 返回指定类型的分类列表。
+     *
+     * @param type 分类类型
+     * @return 分类列表
+     */
+    @GetMapping("/list")
+    @ApiOperation("根据类型查询分类")
+    public Result<List<Category>> list(Integer type) {
+        List<Category> list = categoryService.list(type); // 查询分类列表
+        return Result.success(list); // 返回查询结果
+    }
+}

sky-server/src/main/java/com/sky/controller/admin/DishController.java

@@ -0,0 +1,109 @@
+package com.sky.controller.admin;
+
+
+import com.sky.dto.DishDTO;
+import com.sky.dto.DishPageQueryDTO;
+import com.sky.entity.Dish;
+import com.sky.result.PageResult;
+import com.sky.result.Result;
+import com.sky.service.DishService;
+import com.sky.vo.DishVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Set;
+
+/*
+* 菜品管理
+* */
+@RestController
+@RequestMapping("/admin/dish")
+@Api(tags = "菜品相关接口")
+@Slf4j
+public class DishController {
+
+    @Autowired
+    private DishService dishService;
+    @Autowired
+    private RedisTemplate redisTemplate;
+    @PostMapping
+    @ApiOperation("新增菜品")
+    public Result save(@RequestBody DishDTO dishDTO){
+        log.info("新增菜品：{}",dishDTO);
+        dishService.saveWithFlavor(dishDTO);
+
+        //清理缓存数据
+        String key = "dish_" + dishDTO.getCategoryId();
+        redisTemplate.delete(key);
+        return Result.success();
+    }
+
+    @GetMapping("/page")
+    @ApiOperation("菜品分页查询")
+    public Result<PageResult> page(DishPageQueryDTO dishPageQueryDTO){
+        log.info("菜品分页查询：{}",dishPageQueryDTO);
+        PageResult pageResult = dishService.pageQuery(dishPageQueryDTO);
+        return Result.success(pageResult);
+    }
+
+    @DeleteMapping
+    @ApiOperation("批量删除菜品")
+    public Result delete(@RequestParam List<Long> ids){
+        log.info("菜品批量删除：{}",ids);
+        dishService.deleteBatch(ids);
+
+        //将所有菜品缓存数据清理掉，所有以dish_开头的key
+        cleanCache("dish_*");
+        return Result.success();
+    }
+
+    @GetMapping("/{id}")
+    @ApiOperation("根据菜品id获取信息")
+    public Result<DishVO> getById(@PathVariable Long id){
+        log.info("根据id获取菜品：{}",id);
+        DishVO dishVO = dishService.getById(id);
+        return Result.success(dishVO);
+    }
+
+    @PutMapping
+    @ApiOperation("修改菜品")
+    public Result update(@RequestBody DishDTO dishDTO){
+        log.info("修改菜品：{}",dishDTO);
+        dishService.updateWithFlavor(dishDTO);
+
+        //将所有菜品缓存数据清理掉，所有以dish_开头的key
+        cleanCache("dish_*");
+        return Result.success();
+    }
+
+    @ApiOperation("起售停售菜品")
+    @PostMapping("/status/{status}")
+    public Result StartOrStop(@PathVariable Integer status,Integer id){
+        log.info("起售停售菜品:{}",status == 1 ? "起售" : "停售");
+        dishService.startOrStop(status,id);
+
+        //将所有菜品缓存数据清理掉，所有以dish_开头的key
+        cleanCache("dish_*");
+        return Result.success();
+    }
+    @GetMapping("/list")
+    @ApiOperation("根据分类id查询菜品")
+    public Result<List<Dish>> getByCategoryId(Long categoryId){
+        log.info("根据分类id查询菜品：{}",categoryId);
+        List<Dish> list = dishService.getByCategoryId(categoryId);
+        return Result.success(list);
+    }
+
+    /*
+    * 清理缓存数据
+    * */
+    private void cleanCache(String pattern){
+        Set keys = redisTemplate.keys(pattern);
+        redisTemplate.delete(keys);
+    }
+}

sky-server/src/main/java/com/sky/controller/admin/EmployeeController.java

@@ -0,0 +1,161 @@
+package com.sky.controller.admin;
+
+import com.sky.constant.JwtClaimsConstant;
+import com.sky.dto.EmployeeDTO;
+import com.sky.dto.EmployeeLoginDTO;
+import com.sky.dto.EmployeePageQueryDTO;
+import com.sky.entity.Employee;
+import com.sky.properties.JwtProperties;
+import com.sky.result.PageResult;
+import com.sky.result.Result;
+import com.sky.service.EmployeeService;
+import com.sky.utils.JwtUtil;
+import com.sky.vo.EmployeeLoginVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 员工管理控制器
+ * 提供员工登录、退出、增删改查等功能接口。
+ */
+@RestController
+@RequestMapping("/admin/employee") // 设置路由前缀
+@Slf4j // 日志注解，用于记录日志信息
+@Api(tags = "员工相关接口") // Swagger注解，标注API文档信息
+public class EmployeeController {
+
+    @Autowired
+    private EmployeeService employeeService; // 注入员工服务
+    @Autowired
+    private JwtProperties jwtProperties; // 注入JWT配置属性
+
+    /**
+     * 员工登录
+     * 验证用户登录信息，登录成功后生成JWT令牌并返回。
+     *
+     * @param employeeLoginDTO 员工登录数据传输对象
+     * @return 包含登录信息的响应结果
+     */
+    @ApiOperation(value = "员工登录")
+    @PostMapping("/login")
+    public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
+        log.info("员工登录：{}", employeeLoginDTO); // 打印登录信息
+
+        // 调用服务层方法验证登录信息
+        Employee employee = employeeService.login(employeeLoginDTO);
+
+        // 登录成功后，生成JWT令牌
+        Map<String, Object> claims = new HashMap<>();
+        claims.put(JwtClaimsConstant.EMP_ID, employee.getId());
+        String token = JwtUtil.createJWT(
+                jwtProperties.getAdminSecretKey(), // 密钥
+                jwtProperties.getAdminTtl(),       // 有效期
+                claims                             // 声明内容
+        );
+
+        // 构建返回的登录信息对象
+        EmployeeLoginVO employeeLoginVO = EmployeeLoginVO.builder()
+                .id(employee.getId())
+                .userName(employee.getUsername())
+                .name(employee.getName())
+                .token(token)
+                .build();
+
+        return Result.success(employeeLoginVO); // 返回登录结果
+    }
+
+    /**
+     * 员工退出
+     * 模拟退出功能（如需清理Token相关内容可在此扩展）。
+     *
+     * @return 成功提示信息
+     */
+    @ApiOperation("员工退出")
+    @PostMapping("/logout")
+    public Result<String> logout() {
+        // 通常可添加实际的退出逻辑，如清理会话等
+        return Result.success();
+    }
+
+    /**
+     * 新增员工
+     * 保存新员工信息到数据库。
+     *
+     * @param employeeDTO 员工数据传输对象
+     * @return 成功提示信息
+     */
+    @ApiOperation("新增员工")
+    @PostMapping
+    public Result save(@RequestBody EmployeeDTO employeeDTO) {
+        log.info("新增员工：{}", employeeDTO); // 打印日志
+        System.out.println("当前线程的id：" + Thread.currentThread().getId()); // 输出当前线程ID（示例用）
+        employeeService.save(employeeDTO); // 调用服务层方法保存员工
+        return Result.success();
+    }
+
+    /**
+     * 员工分页查询
+     * 支持分页查询员工列表。
+     *
+     * @param employeePageQueryDTO 分页查询参数
+     * @return 分页结果
+     */
+    @GetMapping("/page")
+    @ApiOperation("员工分页查询")
+    public Result<PageResult> page(EmployeePageQueryDTO employeePageQueryDTO) {
+        log.info("员工分页查询，参数为：{}", employeePageQueryDTO); // 打印查询参数
+        PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO); // 调用分页查询
+        return Result.success(pageResult); // 返回分页结果
+    }
+
+    /**
+     * 启用或禁用员工账号
+     * 根据状态值启用或禁用指定员工。
+     *
+     * @param status 状态值（1-启用，0-禁用）
+     * @param id 员工ID
+     * @return 成功提示信息
+     */
+    @ApiOperation("启用禁用员工账号")
+    @PostMapping("/status/{status}")
+    public Result startOrStop(@PathVariable Integer status, Long id) {
+        log.info("启用禁用员工账号：状态={}, ID={}", status, id); // 打印状态和ID
+        employeeService.startOrStop(status, id); // 调用服务层方法
+        return Result.success();
+    }
+
+    /**
+     * 根据ID查询员工信息
+     * 查询单个员工的详细信息。
+     *
+     * @param id 员工ID
+     * @return 员工实体对象
+     */
+    @GetMapping("{id}")
+    @ApiOperation("根据ID查询员工信息")
+    public Result<Employee> getById(@PathVariable Long id) {
+        Employee employee = employeeService.getById(id); // 根据ID查询员工
+        return Result.success(employee); // 返回查询结果
+    }
+
+    /**
+     * 编辑员工信息
+     * 更新员工的基本信息。
+     *
+     * @param employeeDTO 员工数据传输对象
+     * @return 成功提示信息
+     */
+    @PutMapping
+    @ApiOperation("编辑员工信息")
+    public Result update(@RequestBody EmployeeDTO employeeDTO) {
+        log.info("编辑员工信息：{}", employeeDTO); // 打印日志
+        employeeService.update(employeeDTO); // 调用服务层方法更新员工信息
+        return Result.success();
+    }
+}

sky-server/src/main/java/com/sky/controller/user/CategoryController.java

@@ -0,0 +1,33 @@
+package com.sky.controller.user;
+
+import com.sky.entity.Category;
+import com.sky.result.Result;
+import com.sky.service.CategoryService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import java.util.List;
+
+@RestController("userCategoryController")
+@RequestMapping("/user/category")
+@Api(tags = "C端-分类接口")
+public class CategoryController {
+
+    @Autowired
+    private CategoryService categoryService;
+
+    /**
+     * 查询分类
+     * @param type
+     * @return
+     */
+    @GetMapping("/list")
+    @ApiOperation("查询分类")
+    public Result<List<Category>> list(Integer type) {
+        List<Category> list = categoryService.list(type);
+        return Result.success(list);
+    }
+}

sky-server/src/main/java/com/sky/controller/user/UserController.java

@@ -0,0 +1,55 @@
+package com.sky.controller.user;
+
+import com.sky.constant.JwtClaimsConstant;
+import com.sky.dto.UserLoginDTO;
+import com.sky.entity.User;
+import com.sky.properties.JwtProperties;
+import com.sky.result.Result;
+import com.sky.service.UserService;
+import com.sky.utils.JwtUtil;
+import com.sky.vo.UserLoginVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.HashMap;
+
+@RestController
+@RequestMapping("/user/user")
+@Api(tags = "C端用户相关接口")
+@Slf4j
+public class UserController {
+
+    @Autowired
+    private UserService userService;
+    @Autowired
+    private JwtProperties jwtProperties;
+    /*
+    * 微信登录
+    * */
+    @ApiOperation("微信登录")
+    @PostMapping("/login")
+    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
+        log.info("微信用户登录：{}",userLoginDTO.getCode());
+
+        //微信登录
+        User user = userService.wxLogin(userLoginDTO);
+
+        //为微信用户生成jwt令牌
+        HashMap<String, Object> claims = new HashMap<>();
+        claims.put(JwtClaimsConstant.USER_ID,user.getId());
+        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);
+
+        UserLoginVO userLoginVO = UserLoginVO.builder()
+                .id(user.getId())
+                .openid(user.getOpenid())
+                .token(token)
+                .build();
+        return Result.success(userLoginVO);
+    }
+}

sky-server/src/main/java/com/sky/mapper/CategoryMapper.java

@@ -0,0 +1,53 @@
+package com.sky.mapper;
+
+import com.github.pagehelper.Page;
+import com.sky.annotation.AutoFill;
+import com.sky.enumeration.OperationType;
+import com.sky.dto.CategoryPageQueryDTO;
+import com.sky.entity.Category;
+import org.apache.ibatis.annotations.Delete;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Mapper;
+import java.util.List;
+
+@Mapper
+public interface CategoryMapper {
+
+    /**
+     * 插入数据到category表
+     * @param category 包含要插入的数据的Category对象
+     */
+    @Insert("insert into category(type, name, sort, status, create_time, update_time, create_user, update_user)" +
+            " VALUES" +
+            " (#{type}, #{name}, #{sort}, #{status}, #{createTime}, #{updateTime}, #{createUser}, #{updateUser})")
+    @AutoFill(OperationType.INSERT) // 自动填充创建时间和更新时间等字段
+    void insert(Category category);
+
+    /**
+     * 分页查询分类信息
+     * @param categoryPageQueryDTO 包含分页查询条件的对象
+     * @return 返回分页后的分类列表
+     */
+    Page<Category> pageQuery(CategoryPageQueryDTO categoryPageQueryDTO);
+
+    /**
+     * 根据id删除分类
+     * @param id 要删除的分类的ID
+     */
+    @Delete("delete from category where id = #{id}")
+    void deleteById(Long id);
+
+    /**
+     * 根据id修改分类信息
+     * @param category 包含要更新的数据的Category对象
+     */
+    @AutoFill(OperationType.UPDATE) // 自动填充更新时间等字段
+    void update(Category category);
+
+    /**
+     * 根据类型查询分类列表
+     * @param type 分类的类型
+     * @return 返回对应类型的分类列表
+     */
+    List<Category> list(Integer type);
+}

sky-server/src/main/java/com/sky/mapper/EmployeeMapper.java

@@ -0,0 +1,58 @@
+package com.sky.mapper;
+
+import com.github.pagehelper.Page;
+import com.sky.annotation.AutoFill;
+import com.sky.dto.EmployeePageQueryDTO;
+import com.sky.entity.Employee;
+import com.sky.enumeration.OperationType;
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Select;
+
+/**
+ * EmployeeMapper接口用于定义对员工数据表(employee)的数据库操作方法。
+ */
+@Mapper
+public interface EmployeeMapper {
+
+    /**
+     * 根据用户名查询员工信息。
+     * @param username 员工的用户名。
+     * @return 返回匹配的员工对象，如果没有找到则返回null。
+     */
+    @Select("select * from employee where username = #{username}")
+    Employee getByUsername(String username);
+
+    /**
+     * 插入新的员工记录到数据库中。
+     * @param employee 包含新员工信息的Employee对象。
+     * 使用@AutoFill注解自动填充创建和更新时间以及用户信息。
+     */
+    @Insert("insert into employee(name, username, password, phone, sex, id_number, create_time, update_time, create_user, update_user)" +
+            "values(#{name},#{username},#{password},#{phone},#{sex},#{idNumber},#{createTime},#{updateTime},#{createUser},#{updateUser})")
+    @AutoFill(value = OperationType.INSERT)
+    void insert(Employee employee);
+
+    /**
+     * 分页查询员工信息。
+     * @param employeePageQueryDTO 包含分页查询条件的对象。
+     * @return 返回一个包含分页结果的Page对象。
+     */
+    Page<Employee> pageQuery(EmployeePageQueryDTO employeePageQueryDTO);
+
+    /**
+     * 根据主键动态修改员工的属性。
+     * @param employee 包含需要更新的员工信息的对象。
+     * 使用@AutoFill注解自动填充更新时间和用户信息。
+     */
+    @AutoFill(value = OperationType.UPDATE)
+    void update(Employee employee);
+
+    /**
+     * 根据员工ID查询员工信息。
+     * @param id 员工的ID。
+     * @return 返回匹配的员工对象，如果没有找到则返回null。
+     */
+    @Select("select * from employee where id = #{id}")
+    Employee getById(Long id);
+}

sky-server/src/main/java/com/sky/mapper/UserMapper.java

@@ -1,4 +1,40 @@
 package com.sky.mapper;
 
+import org.apache.ibatis.annotations.Mapper;
+import com.sky.entity.User;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.Map;
+
+@Mapper
 public interface UserMapper {
+
+    /*
+     * 根据openid查询用户
+     * @param openId 用户的OpenID
+     * @return 返回匹配的用户对象，如果没有找到则返回null
+     */
+    @Select("select * from user where openid = #{openid}")
+    User getByOpenId(String openId);
+
+    /*
+     * 插入新的用户数据到数据库中
+     * @param user 包含新用户信息的User对象
+     */
+    void insert(User user);
+
+    /*
+     * 根据用户ID查询用户信息
+     * @param userId 用户的ID
+     * @return 返回匹配的用户对象，如果没有找到则返回null
+     */
+    @Select("select * from user where id = #{id}")
+    User getById(Long userId);
+
+    /*
+     * 根据动态条件统计用户数量
+     * @param map 包含查询条件的Map对象
+     * @return 返回符合条件的用户数量
+     */
+    Integer countByMap(Map map);
 }

sky-server/src/main/java/com/sky/service/CategoryService.java

@@ -0,0 +1,49 @@
+package com.sky.service;
+
+import com.sky.dto.CategoryDTO;
+import com.sky.dto.CategoryPageQueryDTO;
+import com.sky.entity.Category;
+import com.sky.result.PageResult;
+import java.util.List;
+
+public interface CategoryService {
+
+    /**
+     * 新增分类
+     * @param categoryDTO 包含分类信息的数据传输对象
+     */
+    void save(CategoryDTO categoryDTO);
+
+    /**
+     * 分页查询分类信息
+     * @param categoryPageQueryDTO 包含分页查询参数的数据传输对象
+     * @return 返回分页结果，包括当前页数据和分页信息
+     */
+    PageResult pageQuery(CategoryPageQueryDTO categoryPageQueryDTO);
+
+    /**
+     * 根据id删除分类
+     * @param id 要删除的分类的唯一标识符
+     */
+    void deleteById(Long id);
+
+    /**
+     * 修改分类信息
+     * @param categoryDTO 包含更新后的分类信息的数据传输对象
+     */
+    void update(CategoryDTO categoryDTO);
+
+    /**
+     * 启用或禁用分类
+     * @param status 状态值，1表示启用，0表示禁用
+     * @param id 要更改状态的分类的唯一标识符
+     */
+    void startOrStop(Integer status, Long id);
+
+    /**
+     * 根据类型查询分类列表
+     * @param type 分类的类型
+     * @return 返回指定类型的分类列表
+     */
+    List<Category> list(Integer type);
+}

sky-server/src/main/java/com/sky/service/EmployeeService.java

@@ -0,0 +1,50 @@
+package com.sky.service;
+
+import com.sky.dto.EmployeeDTO;
+import com.sky.dto.EmployeeLoginDTO;
+import com.sky.dto.EmployeePageQueryDTO;
+import com.sky.entity.Employee;
+import com.sky.result.PageResult;
+
+public interface EmployeeService {
+
+    /**
+     * 员工登录
+     * @param employeeLoginDTO 包含员工登录信息（如用户名和密码）的数据传输对象
+     * @return 返回登录成功的员工实体，如果登录失败则可能抛出异常或返回null
+     */
+    Employee login(EmployeeLoginDTO employeeLoginDTO);
+
+    /**
+     * 新增员工
+     * @param employeeDTO 包含新员工信息的数据传输对象
+     */
+    void save(EmployeeDTO employeeDTO);
+
+    /**
+     * 分页查询员工信息
+     * @param employeePageQueryDTO 包含分页查询参数的数据传输对象
+     * @return 返回包含员工列表和分页信息的页面结果对象
+     */
+    PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO);
+
+    /**
+     * 启用或禁用员工账号
+     * @param status 状态值，1表示启用，0表示禁用
+     * @param id 要更改状态的员工的唯一标识符
+     */
+    void startOrStop(Integer status, Long id);
+
+    /**
+     * 根据ID获取员工信息
+     * @param id 员工的唯一标识符
+     * @return 返回对应的员工实体
+     */
+    Employee getById(Long id);
+
+    /**
+     * 更新员工信息
+     * @param employeeDTO 包含更新后的员工信息的数据传输对象
+     */
+    void update(EmployeeDTO employeeDTO);
+}

sky-server/src/main/java/com/sky/service/UserService.java

@@ -0,0 +1,19 @@
+package com.sky.service;
+
+import com.sky.dto.UserLoginDTO;
+import com.sky.entity.User;
+
+/**
+ * UserService 接口定义了用户相关的服务方法。
+ */
+public interface UserService {
+
+    /**
+     * 使用微信登录，根据提供的用户登录数据传输对象（UserLoginDTO）进行登录操作。
+     * 如果登录成功，返回对应的用户实体（User），否则可能抛出异常或返回null。
+     *
+     * @param userLoginDTO 包含用户登录信息的数据传输对象，通常包括必要的认证信息如微信的code等。
+     * @return 返回登录成功后的用户实体，如果登录失败则可能抛出异常或返回null。
+     */
+    User wxLogin(UserLoginDTO userLoginDTO);
+}

sky-server/src/main/java/com/sky/service/impl/CategoryServiceImpl.java

@@ -0,0 +1,140 @@
+package com.sky.service.impl;
+
+import com.github.pagehelper.Page;
+import com.github.pagehelper.PageHelper;
+import com.sky.constant.MessageConstant;
+import com.sky.constant.StatusConstant;
+import com.sky.context.BaseContext;
+import com.sky.dto.CategoryDTO;
+import com.sky.dto.CategoryPageQueryDTO;
+import com.sky.entity.Category;
+import com.sky.exception.DeletionNotAllowedException;
+import com.sky.mapper.CategoryMapper;
+import com.sky.mapper.DishMapper;
+import com.sky.mapper.SetmealMapper;
+import com.sky.result.PageResult;
+import com.sky.service.CategoryService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 分类业务层实现类，负责处理与分类相关的业务逻辑。
+ */
+@Service
+@Slf4j
+public class CategoryServiceImpl implements CategoryService {
+
+    @Autowired
+    private CategoryMapper categoryMapper;
+    @Autowired
+    private DishMapper dishMapper;
+    @Autowired
+    private SetmealMapper setmealMapper;
+
+    /**
+     * 新增分类。
+     * @param categoryDTO 包含分类信息的数据传输对象。
+     */
+    public void save(CategoryDTO categoryDTO) {
+        Category category = new Category();
+        // 将categoryDTO中的属性复制到category对象中
+        BeanUtils.copyProperties(categoryDTO, category);
+
+        // 设置分类状态为禁用状态0
+        category.setStatus(StatusConstant.DISABLE);
+
+        // 设置创建时间、修改时间、创建人、修改人（这些代码被注释掉了）
+//        category.setCreateTime(LocalDateTime.now());
+//        category.setUpdateTime(LocalDateTime.now());
+//        category.setCreateUser(BaseContext.getCurrentId());
+//        category.setUpdateUser(BaseContext.getCurrentId());
+
+        // 插入分类数据到数据库
+        categoryMapper.insert(category);
+    }
+
+    /**
+     * 分页查询分类。
+     * @param categoryPageQueryDTO 包含分页查询条件的数据传输对象。
+     * @return 分页结果，包括总记录数和当前页的数据列表。
+     */
+    public PageResult pageQuery(CategoryPageQueryDTO categoryPageQueryDTO) {
+        // 开始分页，并设置分页参数
+        PageHelper.startPage(categoryPageQueryDTO.getPage(), categoryPageQueryDTO.getPageSize());
+        // 执行分页查询，自动加入limit关键字进行分页
+        Page<Category> page = categoryMapper.pageQuery(categoryPageQueryDTO);
+        // 返回分页结果，包括总记录数和当前页的数据列表
+        return new PageResult(page.getTotal(), page.getResult());
+    }
+
+    /**
+     * 根据id删除分类。
+     * @param id 要删除的分类的id。
+     */
+    public void deleteById(Long id) {
+        // 查询当前分类是否关联了菜品，如果关联了就抛出业务异常
+        Integer count = dishMapper.countByCategoryId(id);
+        if (count > 0) {
+            // 当前分类下有菜品，不能删除
+            throw new DeletionNotAllowedException(MessageConstant.CATEGORY_BE_RELATED_BY_DISH);
+        }
+
+        // 查询当前分类是否关联了套餐，如果关联了就抛出业务异常
+        count = setmealMapper.countByCategoryId(id);
+        if (count > 0) {
+            // 当前分类下有套餐，不能删除
+            throw new DeletionNotAllowedException(MessageConstant.CATEGORY_BE_RELATED_BY_SETMEAL);
+        }
+
+        // 删除分类数据
+        categoryMapper.deleteById(id);
+    }
+
+    /**
+     * 修改分类信息。
+     * @param categoryDTO 包含修改后分类信息的数据传输对象。
+     */
+    public void update(CategoryDTO categoryDTO) {
+        Category category = new Category();
+        // 将categoryDTO中的属性复制到category对象中
+        BeanUtils.copyProperties(categoryDTO, category);
+
+        // 设置修改时间、修改人（这些代码被注释掉了）
+//        category.setUpdateTime(LocalDateTime.now());
+//        category.setUpdateUser(BaseContext.getCurrentId());
+
+        // 更新分类数据到数据库
+        categoryMapper.update(category);
+    }
+
+    /**
+     * 启用或禁用分类。
+     * @param status 状态（启用/禁用）。
+     * @param id 要修改状态的分类的id。
+     */
+    public void startOrStop(Integer status, Long id) {
+        // 构建分类对象，并设置其id和状态
+        Category category = Category.builder()
+                .id(id)
+                .status(status)
+//                .updateTime(LocalDateTime.now())
+//                .updateUser(BaseContext.getCurrentId())
+                .build();
+        // 更新分类状态到数据库
+        categoryMapper.update(category);
+    }
+
+    /**
+     * 根据类型查询分类列表。
+     * @param type 类型（1表示菜品分类，2表示套餐分类）。
+     * @return 分类列表。
+     */
+    public List<Category> list(Integer type) {
+        // 根据类型查询分类列表并返回
+        return categoryMapper.list(type);
+    }
+}

sky-server/src/main/java/com/sky/service/impl/EmployeeServiceImpl.java

@@ -0,0 +1,158 @@
+package com.sky.service.impl;
+
+import com.github.pagehelper.Page;
+import com.github.pagehelper.PageHelper;
+import com.sky.constant.MessageConstant;
+import com.sky.constant.PasswordConstant;
+import com.sky.constant.StatusConstant;
+import com.sky.context.BaseContext;
+import com.sky.dto.EmployeeDTO;
+import com.sky.dto.EmployeeLoginDTO;
+import com.sky.dto.EmployeePageQueryDTO;
+import com.sky.entity.Employee;
+import com.sky.exception.AccountLockedException;
+import com.sky.exception.AccountNotFoundException;
+import com.sky.exception.PasswordErrorException;
+import com.sky.mapper.EmployeeMapper;
+import com.sky.result.PageResult;
+import com.sky.service.EmployeeService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.DigestUtils;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class EmployeeServiceImpl implements EmployeeService {
+
+    @Autowired
+    private EmployeeMapper employeeMapper;
+
+    /**
+     * 员工登录
+     *
+     * @param employeeLoginDTO 包含用户名和密码的数据传输对象
+     * @return 返回登录成功的员工实体对象
+     */
+    public Employee login(EmployeeLoginDTO employeeLoginDTO) {
+        String username = employeeLoginDTO.getUsername();
+        String password = employeeLoginDTO.getPassword();
+
+        //1、根据用户名查询数据库中的数据
+        Employee employee = employeeMapper.getByUsername(username);
+
+        //2、处理各种异常情况（用户名不存在、密码不对、账号被锁定）
+        if (employee == null) {
+            //账号不存在
+            throw new AccountNotFoundException(MessageConstant.ACCOUNT_NOT_FOUND);
+        }
+
+        //密码比对
+        //对前端传过来的明文密码进行加密处理
+        password = DigestUtils.md5DigestAsHex(password.getBytes());
+
+        if (!password.equals(employee.getPassword())) {
+            //密码错误
+            throw new PasswordErrorException(MessageConstant.PASSWORD_ERROR);
+        }
+
+        if (employee.getStatus() == StatusConstant.DISABLE) {
+            //账号被锁定
+            throw new AccountLockedException(MessageConstant.ACCOUNT_LOCKED);
+        }
+
+        //3、返回实体对象
+        return employee;
+    }
+
+    /*
+     * 新增员工
+     *
+     * @param employeeDTO 包含新员工信息的数据传输对象
+     */
+    @Override
+    public void save(EmployeeDTO employeeDTO) {
+        System.out.println("当前线程的id：" + Thread.currentThread().getId());
+        Employee employee = new Employee();
+
+        //对象属性拷贝
+        BeanUtils.copyProperties(employeeDTO,employee);
+
+        //设置账户状态为启用
+        employee.setStatus(StatusConstant.ENABLE);
+
+        //设置默认密码并进行加密处理
+        employee.setPassword(DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes()));
+
+//        employee.setCreateTime(LocalDateTime.now()); // 创建时间设置为当前时间
+//        employee.setUpdateTime(LocalDateTime.now()); // 更新时间设置为当前时间
+//        employee.setCreateUser(BaseContext.getCurrentId()); // 创建人ID设置为当前用户ID
+//        employee.setUpdateUser(BaseContext.getCurrentId()); // 更新人ID设置为当前用户ID
+
+        //将新员工信息插入数据库
+        employeeMapper.insert(employee);
+    }
+
+    /*
+     * 分页查询员工列表
+     *
+     * @param employeePageQueryDTO 包含分页查询条件的数据传输对象
+     * @return 返回分页结果，包括总记录数和当前页数据列表
+     */
+    @Override
+    public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {
+        //开始分页查询
+        PageHelper.startPage(employeePageQueryDTO.getPage(),employeePageQueryDTO.getPageSize());
+        Page<Employee> page = employeeMapper.pageQuery(employeePageQueryDTO);
+        long total = page.getTotal(); // 获取总记录数
+        List<Employee> records = page.getResult(); // 获取当前页数据列表
+        return new PageResult(total,records); // 返回分页结果
+    }
+
+    /*
+     * 修改员工状态（启用或禁用）
+     *
+     * @param status 要设置的状态值（启用或禁用）
+     * @param id 要修改的员工ID
+     */
+    @Override
+    public void startOrStop(Integer status, Long id) {
+        //构建员工对象并设置状态和ID
+        Employee employee = Employee.builder()
+                .status(status)
+                .id(id)
+                .build();
+        //更新员工状态到数据库
+        employeeMapper.update(employee);
+    }
+
+    /*
+     * 根据ID查询员工信息，并隐藏密码字段
+     *
+     * @param id 要查询的员工ID
+     * @return 返回查询到的员工实体对象，密码字段被隐藏为"****"
+     */
+    @Override
+    public Employee getById(Long id) {
+        Employee employee = employeeMapper.getById(id); // 根据ID查询员工信息
+        employee.setPassword("****"); // 隐藏密码字段
+        return employee; // 返回查询到的员工信息
+    }
+
+    /*
+     * 更新员工信息
+     *
+     * @param employeeDTO 包含更新后的员工信息的数据传输对象
+     */
+    @Override
+    public void update(EmployeeDTO employeeDTO) {
+        Employee employee = new Employee();
+        BeanUtils.copyProperties(employeeDTO,employee); // 将DTO对象的属性拷贝到实体对象中
+//        employee.setUpdateTime(LocalDateTime.now()); // 更新时间为当前时间
+//        employee.setUpdateUser(BaseContext.getCurrentId()); // 更新人ID设置为当前用户ID
+        //更新员工信息到数据库
+        employeeMapper.update(employee);
+    }
+}

sky-server/src/main/java/com/sky/service/impl/UserServiceImpl.java

@@ -0,0 +1,79 @@
+package com.sky.service.impl;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.sky.constant.MessageConstant;
+import com.sky.dto.UserLoginDTO;
+import com.sky.entity.User;
+import com.sky.exception.LoginFailedException;
+import com.sky.mapper.UserMapper;
+import com.sky.properties.WeChatProperties;
+import com.sky.service.UserService;
+import com.sky.utils.HttpClientUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.http.client.HttpClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+
+@Service
+@Slf4j
+public class UserServiceImpl implements UserService {
+
+    // 微信服务接口地址
+    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";
+    @Autowired
+    private WeChatProperties weChatProperties;
+    @Autowired
+    private UserMapper userMapper;
+
+    /*
+     * 微信登录
+     * @param userLoginDTO 包含用户登录信息的数据传输对象
+     * @return 返回登录的用户对象
+     * @throws LoginFailedException 如果登录失败，抛出此异常
+     */
+    @Override
+    public User wxLogin(UserLoginDTO userLoginDTO) {
+        String openid = getOpenId(userLoginDTO.getCode());
+        // 判断openid是否为空，如果为空则表示获取openid失败，抛出登录失败异常
+        if (openid == null) {
+            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
+        }
+
+        // 根据openid查询当前用户是否是新用户
+        User user = userMapper.getByOpenId(openid);
+        // 如果是新用户，自动完成注册，创建新的用户记录并插入数据库
+        if (user == null) {
+            user = User.builder()
+                    .openid(openid)
+                    .createTime(LocalDateTime.now())
+                    .build();
+            userMapper.insert(user);
+        }
+        // 返回这个用户对象
+        return user;
+    }
+
+    /*
+     * 调用微信接口服务，获取用户openid
+     * @param code 微信登录时获取的临时登录凭证
+     * @return 返回用户的openid
+     */
+    private String getOpenId(String code) {
+        // 调用微信接口服务，获取当前微信用户openid
+        HashMap<String, String> map = new HashMap<>();
+        map.put("appid", weChatProperties.getAppid()); // 微信应用ID
+        map.put("secret", weChatProperties.getSecret()); // 微信应用密钥
+        map.put("js_code", code); // 前端传递的临时登录凭证
+        map.put("grant_type", "authorization_code"); // 授权类型，此处固定为authorization_code
+        String json = HttpClientUtil.doGet(WX_LOGIN, map); // 发送HTTP GET请求到微信服务器，获取响应结果
+
+        JSONObject jsonObject = JSON.parseObject(json); // 将响应结果解析为JSON对象
+        String openid = jsonObject.getString("openid"); // 从JSON对象中提取openid字段的值
+
+        return openid; // 返回openid值
+    }
+}

sky-server/src/main/resources/mapper/CategoryMapper.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<!-- 定义一个MyBatis的映射文件，namespace指定了对应的接口 -->
+<mapper namespace="com.sky.mapper.CategoryMapper">
+
+    <!-- 定义一个查询方法，用于分页查询分类信息 -->
+    <select id="pageQuery" resultType="com.sky.entity.Category">
+        select * from category
+        <!-- 动态SQL，根据条件拼接where子句 -->
+        <where>
+            <!-- 如果name不为空，则添加模糊查询条件 -->
+            <if test="name != null and name != ''">
+                and name like concat('%',#{name},'%')
+            </if>
+            <!-- 如果type不为空，则添加类型过滤条件 -->
+            <if test="type != null">
+                and type = #{type}
+            </if>
+        </where>
+        <!-- 按sort升序和create_time降序排序 -->
+        order by sort asc , create_time desc
+    </select>
+
+    <!-- 定义一个更新方法，用于更新分类信息 -->
+    <update id="update" parameterType="Category">
+        update category
+        <!-- 动态SQL，根据非空字段生成set子句 -->
+        <set>
+            <!-- 如果type不为空，则更新type字段 -->
+            <if test="type != null">
+                type = #{type},
+            </if>
+            <!-- 如果name不为空，则更新name字段 -->
+            <if test="name != null">
+                name = #{name},
+            </if>
+            <!-- 如果sort不为空，则更新sort字段 -->
+            <if test="sort != null">
+                sort = #{sort},
+            </if>
+            <!-- 如果status不为空，则更新status字段 -->
+            <if test="status != null">
+                status = #{status},
+            </if>
+            <!-- 如果updateTime不为空，则更新update_time字段 -->
+            <if test="updateTime != null">
+                update_time = #{updateTime},
+            </if>
+            <!-- 如果updateUser不为空，则更新update_user字段 -->
+            <if test="updateUser != null">
+                update_user = #{updateUser}
+            </if>
+        </set>
+        <!-- 根据id更新记录 -->
+        where id = #{id}
+    </update>
+
+    <!-- 定义一个查询方法，用于获取所有状态为1的分类列表 -->
+    <select id="list" resultType="Category">
+        select * from category
+        where status = 1
+        <!-- 如果type不为空，则添加类型过滤条件 -->
+        <if test="type != null">
+            and type = #{type}
+        </if>
+        <!-- 按sort升序和create_time降序排序 -->
+        order by sort asc,create_time desc
+    </select>
+</mapper>

sky-server/src/main/resources/mapper/EmployeeMapper.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<!-- 定义一个MyBatis的映射文件，namespace指定了对应的接口 -->
+<mapper namespace="com.sky.mapper.EmployeeMapper">
+    <!-- 定义一个更新方法，用于更新员工信息 -->
+    <update id="update" parameterType="Employee">
+        update employee
+        <!-- 动态SQL，根据非空字段生成set子句 -->
+        <set>
+            <!-- 如果name不为空，则更新name字段 -->
+            <if test="name !=null">
+                name = #{name},
+            </if>
+            <!-- 如果username不为空，则更新username字段 -->
+            <if test="username != null">
+                username = #{username},
+            </if>
+            <!-- 如果password不为空，则更新password字段 -->
+            <if test="password != null">
+                password = #{password},
+            </if>
+            <!-- 如果phone不为空，则更新phone字段 -->
+            <if test="phone != null">
+                phone = #{phone},
+            </if>
+            <!-- 如果sex不为空，则更新sex字段 -->
+            <if test="sex != null">
+                sex = #{sex},
+            </if>
+            <!-- 如果idNumber不为空，则更新id_number字段 -->
+            <if test="idNumber != null">
+                id_number = #{idNumber},
+            </if>
+            <!-- 如果updateTime不为空，则更新update_time字段 -->
+            <if test="updateTime != null">
+                update_time = #{updateTime},
+            </if>
+            <!-- 如果updateUser不为空，则更新update_user字段 -->
+            <if test="updateUser != null">
+                update_user = #{updateUser},
+            </if>
+            <!-- 如果status不为空，则更新status字段 -->
+            <if test="status != null">
+                status = #{status},
+            </if>
+        </set>
+        <!-- 根据id更新记录 -->
+        where id = #{id}
+    </update>
+    <!-- 定义一个查询方法，用于分页查询员工信息 -->
+    <select id="pageQuery" resultType="com.sky.entity.Employee">
+        select * from employee
+        <!-- 动态SQL，根据条件拼接where子句 -->
+        <where>
+            <!-- 如果name不为空且不为''，则添加模糊查询条件 -->
+            <if test="name != null and name != ''">
+                and name like concat('%',#{name},'%')
+            </if>
+        </where>
+        <!-- 按create_time降序排序 -->
+        order by create_time desc
+    </select>
+</mapper>

sky-server/src/main/resources/mapper/UserMapper.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<!-- 定义一个MyBatis的映射文件，namespace指定了对应的接口 -->
+<mapper namespace="com.sky.mapper.UserMapper">
+    <!-- 插入用户信息 -->
+    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
+        <!-- 使用自动生成的主键，并将生成的主键值赋给对象的id属性 -->
+        insert into user (openid, name, phone, sex, id_number, avatar, create_time)
+        values
+        (#{openid},#{name},#{phone},#{sex},#{idNumber},#{avatar},#{createTime})
+    </insert>
+    <!-- 根据条件统计用户数量 -->
+    <select id="countByMap" resultType="java.lang.Integer">
+        select count(id)
+        from user
+        <!-- 动态SQL，根据传入的参数拼接where子句 -->
+        <where>
+            <!-- 如果begin不为空，则添加开始时间的条件 -->
+            <if test="begin != null">
+                and create_time &gt; #{begin}
+            </if>
+            <!-- 如果end不为空，则添加结束时间的条件 -->
+            <if test="end != null">
+                and create_time &lt; #{end}
+            </if>
+        </where>
+    </select>
+</mapper>