用户端酒水菜单列表接口新增

alien-entity/src/main/java/shop/alien/mapper/StoreMenuMapper.java

@@ -37,4 +37,38 @@ public interface StoreMenuMapper extends BaseMapper<StoreMenu> {
             "left join store_img b on a.img_id = b.id where a.delete_flag = 0 and b.delete_flag = 0 " +
             "and a.id = #{id}")
     StoreMenuVo getMenuInfo(@Param("id") Integer id);
+
+    /**
+     * 获取菜单（客户端）
+     * <p>
+     * 根据门店ID查询菜单列表，支持按菜品类型和菜单类型筛选。
+     * 查询未删除的菜单及其关联的图片信息。
+     * </p>
+     *
+     * @param storeId      门店ID，必填
+     * @param dishType     菜品类型，可选，0:非推荐, 1:推荐。当为null时，不限制菜品类型
+     * @param dishMenuType 菜单类型，可选，1-菜单，2-酒水。当为null时，不限制菜单类型
+     * @return 菜单列表，包含菜单信息和关联的图片信息
+     */
+    @Select("<script>" +
+            "SELECT " +
+            "    a.*, " +
+            "    b.img_url, " +
+            "    b.img_sort, " +
+            "    b.img_description " +
+            "FROM store_menu a " +
+            "LEFT JOIN store_img b ON a.img_id = b.id " +
+            "WHERE a.delete_flag = 0 " +
+            "    AND (b.delete_flag = 0 OR b.delete_flag IS NULL) " +
+            "    AND a.store_id = #{storeId} " +
+            "<if test='dishType != null'>" +
+            "    AND a.dish_type = #{dishType} " +
+            "</if>" +
+            "<if test='dishMenuType != null'>" +
+            "    AND a.dish_menu_type = #{dishMenuType} " +
+            "</if>" +
+            "</script>")
+    List<StoreMenuVo> getClientMenuByStoreId(@Param("storeId") Integer storeId, 
+                                             @Param("dishType") Integer dishType, 
+                                             @Param("dishMenuType") Integer dishMenuType);
 }

alien-store/src/main/java/shop/alien/store/controller/StoreMenuController.java

@@ -122,4 +122,57 @@ public class StoreMenuController {
         log.info("StoreRecommendController.getMenuLikeStatus?userId={}&menuId={}", userId, menuId);
         return R.data(storeMenuService.getMenuLikeStatus(userId, menuId));
     }
+
+    /**
+     * 获取菜单（用户端）
+     * <p>
+     * 根据门店ID获取菜单列表，支持按菜品类型、菜单类型筛选，并可查询用户点赞状态
+     * </p>
+     *
+     * @param storeId      门店ID，必填，必须大于0
+     * @param dishType     菜品类型，可选，0:非推荐, 1:推荐
+     * @param phoneId      用户手机号，可选，用于查询点赞状态
+     * @param dishMenuType 菜单类型，可选，1-菜单，2-酒水
+     * @return 统一返回结果，包含菜单列表
+     * @throws IllegalArgumentException 当门店ID为空或小于等于0时抛出
+     */
+    @ApiOperation("获取菜单（用户端）")
+    @ApiOperationSupport(order = 9)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "storeId", value = "门店id", dataType = "Integer", paramType = "query", required = true),
+            @ApiImplicitParam(name = "dishType", value = "菜品类型, 0:（推荐+非推荐）, 1:推荐", dataType = "Integer", paramType = "query"),
+            @ApiImplicitParam(name = "phoneId", value = "用户手机号", dataType = "String", paramType = "query"),
+            @ApiImplicitParam(name = "dishMenuType", value = "菜单类型：1-菜单，2-酒水", dataType = "Integer", paramType = "query")
+    })
+    @GetMapping("/getClientMenuByStoreId")
+    public R<List<StoreMenuVo>> getClientMenuByStoreId(
+            @RequestParam(value = "storeId", required = true) Integer storeId,
+            @RequestParam(value = "dishType", required = false) Integer dishType,
+            @RequestParam(value = "phoneId", required = false) String phoneId,
+            @RequestParam(value = "dishMenuType", required = false) Integer dishMenuType) {
+        // 记录请求入参
+        log.info("获取用户端菜单，入参：storeId={}, dishType={}, phoneId={}, dishMenuType={}", 
+                storeId, dishType, phoneId, dishMenuType);
+        
+        // 参数校验
+        if (storeId == null || storeId <= 0) {
+            log.warn("获取用户端菜单失败，门店ID无效：storeId={}", storeId);
+            return R.fail("门店ID不能为空且必须大于0");
+        }
+        
+        try {
+            // 调用服务层获取菜单列表
+            List<StoreMenuVo> menuList = storeMenuService.getClientMenuByStoreId(
+                    storeId, dishType, phoneId, dishMenuType);
+            
+            // 记录返回结果
+            log.info("获取用户端菜单成功，门店ID：{}，返回菜单数量：{}", 
+                    storeId, menuList != null ? menuList.size() : 0);
+            
+            return R.data(menuList);
+        } catch (Exception e) {
+            log.error("获取用户端菜单异常，门店ID：{}，异常信息：{}", storeId, e.getMessage(), e);
+            return R.fail("获取菜单失败：" + e.getMessage());
+        }
+    }
 }

alien-store/src/main/java/shop/alien/store/service/StoreMenuService.java

@@ -79,5 +79,22 @@ public interface StoreMenuService extends IService<StoreMenu> {
      * @return boolean
      */
     boolean getMenuLikeStatus(String userId, Integer menuId);
+
+    /**
+     * 获取门店菜单（客户端）
+     * <p>
+     * 根据门店ID查询菜单列表，支持按菜品类型和菜单类型筛选。
+     * 当查询推荐菜且提供用户手机号时，会批量查询并设置用户的点赞状态。
+     * 最终结果按排序字段升序排列。
+     * </p>
+     *
+     * @param storeId      门店ID，必填，必须大于0
+     * @param dishType     菜品类型，可选，0:非推荐, 1:推荐。当为0时，查询条件中不包含菜品类型限制
+     * @param phoneId      用户手机号，可选，用于查询用户对推荐菜的点赞状态
+     * @param dishMenuType 菜单类型，可选，1-菜单，2-酒水
+     * @return 菜单列表，按排序字段升序排列，如果查询结果为空则返回空列表
+     * @throws IllegalArgumentException 当门店ID为空或小于等于0时抛出
+     */
+    List<StoreMenuVo> getClientMenuByStoreId(Integer storeId, Integer dishType, String phoneId, Integer dishMenuType);
 }
 

alien-store/src/main/java/shop/alien/store/service/impl/StoreMenuServiceImpl.java

@@ -49,6 +49,27 @@ public class StoreMenuServiceImpl extends ServiceImpl<StoreMenuMapper, StoreMenu
     private final LifeGroupBuyThaliMapper lifeGroupBuyThaliMapper;
 
     /**
+     * 菜品类型：非推荐
+     */
+    private static final Integer DISH_TYPE_NON_RECOMMEND = 0;
+
+    /**
+     * 菜品类型：推荐
+     */
+    private static final Integer DISH_TYPE_RECOMMEND = 1;
+
+    /**
+     * 点赞状态：未点赞
+     */
+    private static final Integer LIKE_STATUS_NO = 0;
+
+    /**
+     * 点赞状态：已点赞
+     */
+    private static final Integer LIKE_STATUS_YES = 1;
+
+
+    /**
      * 获取门店菜单
      *
      * @param storeId      门店id
@@ -249,7 +270,7 @@ public class StoreMenuServiceImpl extends ServiceImpl<StoreMenuMapper, StoreMenu
         if (dishType == 0) {
             List<LifeGroupBuyThali> lifeGroupBuyThaliList = lifeGroupBuyThaliMapper.selectList(new LambdaQueryWrapper<LifeGroupBuyThali>().in(LifeGroupBuyThali::getDetailId, ids));
             if (CollectionUtil.isNotEmpty(lifeGroupBuyThaliList)) {
-                return R.fail("当前菜品存在于团购中，不可删除");
+                return R.fail("该菜品已被团购套餐引用，不能删除");
             }
             flag = this.removeByIds(ids);
         } else {
@@ -302,4 +323,120 @@ public class StoreMenuServiceImpl extends ServiceImpl<StoreMenuMapper, StoreMenu
     public boolean getMenuLikeStatus(String userId, Integer menuId) {
         return lifeLikeRecordMapper.selectCount(new QueryWrapper<LifeLikeRecord>().eq("dianzan_id", userId).eq("huifu_id", menuId).eq("delete_flag", 0)) > 0;
     }
+
+    /**
+     * 获取门店菜单（客户端）
+     * <p>
+     * 根据门店ID查询菜单列表，支持按菜品类型和菜单类型筛选。
+     * 当查询推荐菜且提供用户手机号时，会批量查询并设置用户的点赞状态。
+     * 最终结果按排序字段升序排列。
+     * </p>
+     *
+     * @param storeId      门店ID，必填，必须大于0
+     * @param dishType     菜品类型，可选，0:全部, 1:推荐
+     * @param phoneId      用户手机号，可选，用于查询用户对推荐菜的点赞状态
+     * @param dishMenuType 菜单类型，可选，1-菜单，2-酒水
+     * @return 菜单列表，按排序字段升序排列，如果查询结果为空则返回空列表
+     */
+    @Override
+    public List<StoreMenuVo> getClientMenuByStoreId(Integer storeId, Integer dishType, String phoneId, Integer dishMenuType) {
+        log.info("开始获取用户端菜单，门店ID：{}，菜品类型：{}，用户手机号：{}，菜单类型：{}",
+                storeId, dishType, phoneId, dishMenuType);
+
+        // 参数校验
+        if (storeId == null || storeId <= 0) {
+            log.warn("获取用户端菜单失败，门店ID无效：{}", storeId);
+            throw new IllegalArgumentException("门店ID不能为空且必须大于0");
+        }
+
+        // 处理菜品类型参数：当dishType为0时，转换为null以查询所有类型
+        Integer queryDishType = (DISH_TYPE_NON_RECOMMEND.equals(dishType)) ? null : dishType;
+
+        // 查询菜单列表
+        List<StoreMenuVo> menuList = storeMenuMapper.getClientMenuByStoreId(storeId, queryDishType, dishMenuType);
+
+        // 如果查询结果为空，直接返回空列表
+        if (CollectionUtils.isEmpty(menuList)) {
+            log.info("获取用户端菜单完成，门店ID：{}，未查询到菜单数据", storeId);
+            return menuList;
+        }
+
+        log.info("获取用户端菜单，门店ID：{}，查询到菜单数量：{}", storeId, menuList.size());
+
+        // 如果是推荐菜且有用户标识，批量查询并设置点赞状态
+        if (DISH_TYPE_RECOMMEND.equals(dishType) && StringUtils.isNotEmpty(phoneId)) {
+            setLikeStatusForMenuList(menuList, phoneId);
+        } else {
+            // 非推荐菜或未提供用户手机号时，设置默认未点赞状态
+            menuList.forEach(item -> item.setIsLike(LIKE_STATUS_NO));
+        }
+
+        // 按排序字段升序排序
+        List<StoreMenuVo> sortedMenuList = menuList.stream()
+                .sorted(Comparator.comparing(StoreMenuVo::getSort, Comparator.nullsLast(Integer::compareTo)))
+                .collect(Collectors.toList());
+
+        log.info("获取用户端菜单完成，门店ID：{}，返回菜单数量：{}", storeId, sortedMenuList.size());
+
+        return sortedMenuList;
+    }
+
+    /**
+     * 批量设置菜单的点赞状态
+     * <p>
+     * 根据用户手机号和菜单ID列表，批量查询点赞记录，并设置每个菜单的点赞状态
+     * </p>
+     *
+     * @param menuList 菜单列表
+     * @param phoneId  用户手机号
+     */
+    private void setLikeStatusForMenuList(List<StoreMenuVo> menuList, String phoneId) {
+        if (CollectionUtils.isEmpty(menuList) || StringUtils.isEmpty(phoneId)) {
+            return;
+        }
+
+        log.debug("开始批量查询点赞状态，用户手机号：{}，菜单数量：{}", phoneId, menuList.size());
+
+        // 将菜单ID转换为String集合，用于查询点赞记录
+        Set<String> menuIdStrSet = menuList.stream()
+                .map(item -> String.valueOf(item.getId()))
+                .filter(id -> id != null && !"null".equals(id))
+                .collect(Collectors.toSet());
+
+        if (menuIdStrSet.isEmpty()) {
+            log.warn("菜单ID集合为空，无法查询点赞状态");
+            menuList.forEach(item -> item.setIsLike(LIKE_STATUS_NO));
+            return;
+        }
+
+        // 批量查询点赞记录
+        LambdaQueryWrapper<LifeLikeRecord> likeQuery = new LambdaQueryWrapper<>();
+        likeQuery.eq(LifeLikeRecord::getDianzanId, phoneId)
+                .in(LifeLikeRecord::getHuifuId, menuIdStrSet);
+        List<LifeLikeRecord> likeRecordList = lifeLikeRecordMapper.selectList(likeQuery);
+
+        // 构建已点赞的菜单ID集合
+        Set<String> likedMenuIdSet = likeRecordList.stream()
+                .map(LifeLikeRecord::getHuifuId)
+                .filter(id -> id != null)
+                .collect(Collectors.toSet());
+
+        log.debug("查询到点赞记录数量：{}，已点赞菜单数量：{}",
+                likeRecordList.size(), likedMenuIdSet.size());
+
+        // 设置点赞状态
+        menuList.forEach(item -> {
+            if (item.getId() == null) {
+                item.setIsLike(LIKE_STATUS_NO);
+                return;
+            }
+
+            String menuIdStr = String.valueOf(item.getId());
+            if (likedMenuIdSet.contains(menuIdStr)) {
+                item.setIsLike(LIKE_STATUS_YES);
+            } else {
+                item.setIsLike(LIKE_STATUS_NO);
+            }
+        });
+    }
 }

alien-store/src/main/java/shop/alien/store/strategy/payment/impl/WeChatPaymentStrategyImpl.java

@@ -140,8 +140,8 @@ public class WeChatPaymentStrategyImpl implements PaymentStrategy {
             privateKeyPath = privateLinuxKeyPath;
             wechatPayPublicKeyFilePath = wechatLinuxPayPublicKeyFilePath;
         }
-        this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyPath);
-        this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
+       // this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyPath);
+        //this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
     }
 
     @Override