商家平台端门店装修

alien-store-platform/src/main/java/shop/alien/storeplatform/controller/StorePlatformBusinessInfoController.java

@@ -0,0 +1,114 @@
+package shop.alien.storeplatform.controller;
+
+
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.StoreBusinessInfo;
+import shop.alien.mapper.StoreBusinessInfoMapper;
+import shop.alien.storeplatform.service.StorePlatformBusinessInfoService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+
+/**
+ * 门店营业时间Controller
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+@Slf4j
+@Api(tags = {"商户平台-门店营业信息"})
+@ApiSort(2)
+@CrossOrigin
+@RestController
+@RequestMapping("/storePlatformBusinessInfo")
+@RequiredArgsConstructor
+public class StorePlatformBusinessInfoController {
+
+    private final StorePlatformBusinessInfoService storeBusinessInfoService;
+
+    private final StoreBusinessInfoMapper storeBusinessInfoMapper;
+
+    @ApiOperation("获取门店营业信息")
+    @ApiOperationSupport(order = 1)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "storeId", value = "门店id", dataType = "Long", paramType = "query", required = true)
+    })
+    @GetMapping("/getByStoreId")
+    public R<List<StoreBusinessInfo>> getByStoreId(Long storeId) {
+        log.info("StorePlatformBusinessInfoController.getByStoreId?storeId={}", storeId);
+        return R.data(storeBusinessInfoService.getStoreBusinessInfo(storeId));
+    }
+
+    @ApiOperation("新增或修改门店营业信息")
+    @ApiOperationSupport(order = 2)
+    @PostMapping("/saveOrUpdate")
+    public R<Boolean> saveOrUpdate(@RequestBody StoreBusinessInfo storeBusinessInfo) {
+        log.info("StorePlatformBusinessInfoController.order?storeBusinessInfo={}", storeBusinessInfo);
+        if (storeBusinessInfoService.saveOrUpdate(storeBusinessInfo)) {
+            if (null != storeBusinessInfo.getId()) {
+                return R.success("修改成功");
+            }
+            return R.success("新增成功");
+        }
+        return R.fail("新增失败");
+    }
+
+    @ApiOperation("新增或修改门店营业信息批量保存")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/saveOrUpdateList")
+    public R<Boolean> saveOrUpdateList(@RequestBody List<StoreBusinessInfo> businessInfoList) {
+        log.info("StorePlatformBusinessInfoController.order?storeBusinessInfoVo={}", businessInfoList);
+        boolean flag = false;
+        List<StoreBusinessInfo> toSave = new ArrayList<>();
+        List<StoreBusinessInfo> toUpdate = new ArrayList<>();
+        for (StoreBusinessInfo businessInfo : businessInfoList) {
+            if (businessInfo.getId() == null || businessInfo.getId() == 0) {
+                toSave.add(businessInfo);
+            } else {
+                toUpdate.add(businessInfo);
+            }
+        }
+
+        if (!toSave.isEmpty()) {
+            //清除该店铺原始营业数据
+            Optional<Integer> storeId = businessInfoList.stream().map(StoreBusinessInfo::getStoreId).findFirst();
+            int value = storeId.orElse(0);
+            LambdaUpdateWrapper<StoreBusinessInfo> lambdaQueryWrapper = new LambdaUpdateWrapper<>();
+            lambdaQueryWrapper.eq(StoreBusinessInfo::getStoreId,value);
+            lambdaQueryWrapper.set(StoreBusinessInfo::getDeleteFlag,1);
+            storeBusinessInfoMapper.update(null,lambdaQueryWrapper);
+            flag = storeBusinessInfoService.saveBatch(toSave); // 批量保存
+        }
+        if(!toUpdate.isEmpty()){
+            flag = storeBusinessInfoService.updateBatchById(toUpdate); // 批量更新
+        }
+        if(flag){
+            return R.success("成功");
+        }else{
+            return R.fail("失败");
+        }
+    }
+
+    @ApiOperation(value = "删除门店营业信息")
+    @ApiOperationSupport(order = 3)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "id", value = "主键id", dataType = "Long", paramType = "query", required = true)
+    })
+    @GetMapping("/delete")
+    public R<String> delete(Integer id) {
+        log.info("StorePlatformBusinessInfoController.delete?ids={}", id);
+        if (storeBusinessInfoService.removeById(id)) {
+            return R.success("删除成功");
+        }
+        return R.fail("删除失败");
+    }
+
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/controller/StorePlatformMenuController.java

@@ -0,0 +1,119 @@
+package shop.alien.storeplatform.controller;
+
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.StoreMenu;
+import shop.alien.entity.store.vo.StoreMenuVo;
+import shop.alien.storeplatform.service.StorePlatformMenuService;
+
+import java.util.List;
+
+/**
+ * 二期-门店菜单Controller
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+@Slf4j
+@Api(tags = {"二期-门店菜单"})
+@ApiSort(4)
+@CrossOrigin
+@RestController
+@RequestMapping("/menu")
+@RequiredArgsConstructor
+public class StorePlatformMenuController {
+
+    private final StorePlatformMenuService storeMenuService;
+
+    @ApiOperation("获取门店菜单")
+    @ApiOperationSupport(order = 1)
+    @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 = "Integer", paramType = "query")
+    })
+    @GetMapping("/getMenuByStoreId")
+    public R<List<StoreMenuVo>> getMenuByStoreId(Integer storeId, Integer dishType, String phoneId) {
+        log.info("StoreRecommendController.getByStoreId?id={}&dishType={}&phoneId={}", storeId, dishType, phoneId);
+        return R.data(storeMenuService.getStoreMenu(storeId, dishType, phoneId));
+    }
+
+    @ApiOperation("新增或修改门店菜单")
+    @ApiOperationSupport(order = 2)
+    @PostMapping("/saveOrUpdate")
+    public R<String> saveOrUpdate(@RequestBody StoreMenuVo storeMenuVo) {
+        log.info("StoreRecommendController.saveOrUpdateMenu?storeMenu={}", storeMenuVo);
+        return storeMenuService.saveOrUpdateMenus(storeMenuVo);
+    }
+
+    @ApiOperation(value = "删除门店菜单")
+    @ApiOperationSupport(order = 3)
+    @GetMapping("/delete")
+    public R<String> delete(@RequestParam(value = "ids") List<Integer> ids, @RequestParam(value = "dishType") int dishType) {
+        log.info("StoreRecommendController.delete?ids={}", ids);
+        return storeMenuService.deleteMenu(ids, dishType);
+    }
+
+    @ApiOperation("获取菜品详情")
+    @ApiOperationSupport(order = 4)
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "菜品id", dataType = "Integer", paramType = "query")})
+    @GetMapping("/getMenuInfo")
+    public R<StoreMenuVo> getMenuInfo(Integer id) {
+        log.info("StoreRecommendController.getMenuInfo?id={}", id);
+        return R.data(storeMenuService.getMenuInfo(id));
+    }
+
+    @ApiOperation("菜品排序")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/getSortMenuInfo")
+    public R<Boolean> getSortMenuInfo(@RequestBody StoreMenuVo storeMenuVo) {
+        log.info("StoreRecommendController.getSortMenuInfo?storeMenuVo={}", storeMenuVo);
+        Boolean flag = false;
+        flag = storeMenuService.getSortMenuInfo(storeMenuVo);
+        if (flag) {
+            return R.success("已更新排序");
+        } else {
+            return R.fail("排序失败");
+        }
+    }
+
+    @ApiOperation("保存菜品排序")
+    @ApiOperationSupport(order = 6)
+    @PostMapping("/saveMenuSort")
+    public R<Boolean> saveMenuSort(@RequestBody List<StoreMenu> storeMenuList) {
+        log.info("StoreRecommendController.saveMenuSort?storeMenuList={}", storeMenuList);
+        Boolean flag = false;
+        flag = storeMenuService.saveMenuSort(storeMenuList);
+        if (flag) {
+            return R.success("已更新排序");
+        } else {
+            return R.fail("排序失败");
+        }
+    }
+
+    @ApiOperation("获取门店菜品推荐数量")
+    @ApiOperationSupport(order = 7)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "storeId", value = "门店id", dataType = "Integer", paramType = "query", required = true)
+    })
+    @GetMapping("/getMenuCountByStoreId")
+    public R<StoreMenuVo> getMenuCountByStoreId(Integer storeId) {
+        log.info("StoreRecommendController.getMenuCountByStoreId?id={}", storeId);
+        return R.data(storeMenuService.getMenuCountByStoreId(storeId));
+    }
+
+    @ApiOperation("获取用户对该菜品是否点赞")
+    @ApiOperationSupport(order = 8)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "userId", value = "用户id", dataType = "String", paramType = "query", required = true),
+            @ApiImplicitParam(name = "menuId", value = "菜品id", dataType = "Integer", paramType = "query", required = true)
+    })
+    @GetMapping("/getMenuLikeStatus")
+    public R<Boolean> getMenuLikeStatus(String userId, Integer menuId) {
+        log.info("StoreRecommendController.getMenuLikeStatus?userId={}&menuId={}", userId, menuId);
+        return R.data(storeMenuService.getMenuLikeStatus(userId, menuId));
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/controller/StorePlatformOfficialAlbumController.java

@@ -0,0 +1,62 @@
+package shop.alien.storeplatform.controller;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiOperationSupport;
+import io.swagger.annotations.ApiSort;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.StoreOfficialAlbum;
+import shop.alien.entity.store.vo.StoreOfficialAlbumVo;
+import shop.alien.storeplatform.service.StorePlatformOfficialAlbumService;
+
+import java.util.List;
+
+/**
+ * 官方相册前端控制器
+ *
+ * @author zhangchen
+ * @since 2025-07-16
+ */
+@Slf4j
+@Api(tags = {"二期-官方相册"})
+@ApiSort(1)
+@CrossOrigin
+@RestController
+@RequestMapping("/store/official")
+@RequiredArgsConstructor
+public class StorePlatformOfficialAlbumController {
+    private final StorePlatformOfficialAlbumService storeOfficialAlbumService;
+
+    @ApiOperation("创建/更新官方相册")
+    @ApiOperationSupport(order = 1)
+    @PostMapping("/createOrUpdateOfficialAlbum")
+    public R<StoreOfficialAlbum> createOrUpdateOfficialAlbum(@RequestBody StoreOfficialAlbum storeOfficialAlbum) {
+        log.info("StoreOfficialAlbumController.createOfficialAlbum?storeOfficialAlbum={}", storeOfficialAlbum);
+        StoreOfficialAlbum storeOfficial = storeOfficialAlbumService.createOrUpdateOfficialAlbum(storeOfficialAlbum);
+        return R.data(storeOfficial);
+    }
+
+    @ApiOperation("获取官方相册列表")
+    @ApiOperationSupport(order = 2)
+    @GetMapping("/getOfficialAlbumList")
+    public R<List<StoreOfficialAlbumVo>> getOfficialAlbumList(String storeId) {
+        log.info("StoreOfficialAlbumController.getOfficialAlbumList");
+        List<StoreOfficialAlbumVo> storeOfficialAlbumList = storeOfficialAlbumService.getOfficialAlbumList(storeId);
+        return R.data(storeOfficialAlbumList);
+    }
+
+    @ApiOperation("删除官方相册")
+    @ApiOperationSupport(order = 3)
+    @PostMapping("/deleteOfficialAlbum")
+    public  R<Boolean> deleteOfficialAlbum(@RequestBody List<StoreOfficialAlbum> storeOfficialAlbumList) {
+        log.info("StoreOfficialAlbumController.deleteOfficialAlbum");
+        int result = storeOfficialAlbumService.deleteOfficialAlbum(storeOfficialAlbumList);
+        if (result > 0) {
+            return R.data(true);
+        }
+        return R.fail("失败");
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/controller/StorePlatformRenovationController.java

@@ -0,0 +1,42 @@
+package shop.alien.storeplatform.controller;
+
+import io.swagger.annotations.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.vo.StoreDictionaryVo;
+import shop.alien.entity.store.vo.StoreMainInfoVo;
+import shop.alien.storeplatform.service.StorePlatformRenovationService;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Api(tags = {"商户平台-门店装修"})
+@ApiSort(1)
+@CrossOrigin
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/storePlatformRenovation")
+public class StorePlatformRenovationController {
+
+    private final StorePlatformRenovationService storePlatformRenovationService;
+
+    @ApiOperation(value = "web端查询经营板块信息")
+    @ApiOperationSupport(order = 1)
+    @GetMapping("/getBusinessSection")
+    public R<List<StoreDictionaryVo>> getBusinessSection() {
+        log.info("StorePlatformRenovationController.getBusinessSection");
+        return R.data(new ArrayList<>());
+    }
+
+    @ApiOperation(value = "门店装修-详细信息")
+    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "门店id", dataType = "Long", paramType = "query", required = true)})
+    @GetMapping("/getDecorationDetail")
+    public R<StoreMainInfoVo> getDecorationDetail(Integer id) {
+        log.info("StorePlatformRenovationController.getDecorationDetail?id={}", id);
+        return R.data(storePlatformRenovationService.getDecorationDetail(id));
+    }
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/controller/StorePlatformTagCategoryController.java

@@ -0,0 +1,147 @@
+package shop.alien.storeplatform.controller;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiOperationSupport;
+import io.swagger.annotations.ApiSort;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.TagBusinessRelation;
+import shop.alien.entity.store.TagCategory;
+import shop.alien.entity.store.TagStoreRelation;
+import shop.alien.entity.store.vo.TagCategoryVo;
+import shop.alien.storeplatform.service.StorePlatformTagBusinessRelationService;
+import shop.alien.storeplatform.service.StorePlatformTagCategoryService;
+import shop.alien.storeplatform.service.StorePlatformTagRelationService;
+
+import java.util.List;
+
+/**
+ * 标签前端控制器
+ *
+ * @author zhangchen
+ * @since 2025-07-16
+ */
+@Slf4j
+@Api(tags = {"商户平台-标签信息"})
+@ApiSort(1)
+@CrossOrigin
+@RestController
+@RequestMapping("/store/tag")
+@RequiredArgsConstructor
+public class StorePlatformTagCategoryController {
+    private final StorePlatformTagCategoryService tagCategoryService;
+    private final StorePlatformTagBusinessRelationService storeTagBusinessRelationService;
+    private final StorePlatformTagRelationService tagStoreRelationService;
+
+    @ApiOperation("创建标签")
+    @ApiOperationSupport(order = 1)
+    @PostMapping("/createTag")
+    public R<TagCategory> createTag(@RequestBody TagCategory tagCategory) {
+        log.info("TagCategoryController.createTag?tagCategoryVO={}", tagCategory);
+        TagCategory tag = tagCategoryService.createTag(tagCategory);
+        return R.data(tag);
+    }
+
+    @ApiOperation("获取标签列表")
+    @ApiOperationSupport(order = 2)
+    @GetMapping("/getTagList")
+    public R<IPage<TagCategory>> getTagList(@RequestParam(defaultValue = "1") int pageNum,
+                                            @RequestParam(defaultValue = "10") int pageSize,
+                                            @RequestParam(required = false) String label,
+                                            @RequestParam(required = false) String labelType,
+                                            @RequestParam(required = false) String labelButtonType
+    ) {
+        log.info("TagCategoryController.getTagList");
+        IPage<TagCategory> storeCouponList = tagCategoryService.getTagList(pageNum, pageSize,label,labelType,labelButtonType);
+        return R.data(storeCouponList);
+    }
+
+    @ApiOperation("删除标签")
+    @ApiOperationSupport(order = 3)
+    @PostMapping("/deleteTagCategory")
+    public  R<Boolean> deleteTagCategory(@RequestBody TagCategory tagCategory) {
+        log.info("TagCategoryController.deleteTagCategory");
+        int result = tagCategoryService.deleteTag(tagCategory);
+        if (result > 0) {
+            return R.data(true);
+        }
+        return R.fail("失败");
+    }
+
+    @ApiOperation("修改标签")
+    @ApiOperationSupport(order = 4)
+    @PostMapping("/updateTagCategory")
+    public R<Boolean> updateTagCategory(@RequestBody TagCategory tagCategory) {
+        log.info("TagCategoryController.updateTagCategory?tagCategory={}", tagCategory);
+        int num = tagCategoryService.updateTagCategory(tagCategory);
+        if (num > 0) {
+            return R.data(true);
+        }
+        return R.fail("失败");
+    }
+
+    @ApiOperation("创建标签经营类型关系")
+    @ApiOperationSupport(order = 5)
+    @PostMapping("/createTagBusinessRelation")
+    public R<TagBusinessRelation> createTagBusinessRelation(@RequestBody TagBusinessRelation tagBusinessRelation) {
+        log.info("TagCategoryController.createTagBusinessRelation?tagBusinessRelation={}", tagBusinessRelation);
+        TagBusinessRelation tag = storeTagBusinessRelationService.createTagBusinessRelation(tagBusinessRelation);
+        return R.data(tag);
+    }
+
+    @ApiOperation("获取经营类型标签信息")
+    @ApiOperationSupport(order = 6)
+    @GetMapping("/getBusinessRelationTagList")
+    public R<List<TagCategoryVo>> getBusinessRelationTagList(@RequestParam(required = false) Integer businessSection) {
+        log.info("TagCategoryController.getBusinessRelationTagList");
+        List<TagCategoryVo> tagCategoryVoList = tagCategoryService.getBusinessRelationTagList(businessSection);
+        return R.data(tagCategoryVoList);
+    }
+
+
+    @ApiOperation("获取标签经营类型关系")
+    @ApiOperationSupport(order = 7)
+    @GetMapping("/getTagBusinessRelationList")
+    public R<IPage<TagBusinessRelation>> getTagBusinessRelationList(@RequestParam(defaultValue = "1") int page,
+                                            @RequestParam(defaultValue = "10") int size, @RequestParam(required = false) int businessSection,
+                                            @RequestParam(required = false) String businessSectionName
+    ) {
+        log.info("TagCategoryController.getTagBusinessRelationList");
+        IPage<TagBusinessRelation> tagBusinessRelationList = storeTagBusinessRelationService.getTagBusinessRelationList(page, size, businessSection, businessSectionName);
+        return R.data(tagBusinessRelationList);
+    }
+
+    @ApiOperation("删除标签经营类型关系")
+    @ApiOperationSupport(order = 8)
+    @PostMapping("/deleteTagBusinessRelation")
+    public  R<Boolean> deleteTagBusinessRelation(@RequestBody TagBusinessRelation tagBusinessRelation) {
+        log.info("TagCategoryController.deleteTagBusinessRelation");
+        int result = storeTagBusinessRelationService.deleteTagBusinessRelation(tagBusinessRelation);
+        if (result > 0) {
+            return R.data(true);
+        }
+        return R.fail("失败");
+    }
+
+    @ApiOperation("创建/更新店铺标签关系")
+    @ApiOperationSupport(order = 9)
+    @PostMapping("/createOrUpdateTagStoreRelation")
+    public R<TagStoreRelation> createOrUpdateTagStoreRelation(@RequestBody TagStoreRelation tagStoreRelation) {
+        log.info("TagCategoryController.createOrUpdateTagStoreRelation?tagStoreRelation={}", tagStoreRelation);
+        TagStoreRelation tag = tagStoreRelationService.createOrUpdateTagStoreRelation(tagStoreRelation);
+        return R.data(tag);
+    }
+
+    @ApiOperation("获取标签经营类型关系")
+    @ApiOperationSupport(order = 10)
+    @GetMapping("/getTagStoreRelationByStoreId")
+    public R<TagStoreRelation> getTagStoreRelationByStoreId( @RequestParam(required = true) Integer storeId) {
+        log.info("TagCategoryController.getTagStoreRelationByStoreId={}", storeId);
+        TagStoreRelation tagStoreRelation = tagStoreRelationService.getTagStoreRelationByStoreId(storeId);
+        return R.data(tagStoreRelation);
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformBusinessInfoService.java

@@ -0,0 +1,24 @@
+package shop.alien.storeplatform.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.store.StoreBusinessInfo;
+
+import java.util.List;
+
+/**
+ * 二期-门店营业时间 服务类
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+public interface StorePlatformBusinessInfoService extends IService<StoreBusinessInfo> {
+
+    /**
+     * 获取门店营业信息
+     *
+     * @param storeId 门店信息
+     * @return list
+     */
+    List<StoreBusinessInfo> getStoreBusinessInfo(Long storeId);
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformImgService.java

@@ -0,0 +1,8 @@
+package shop.alien.storeplatform.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.store.StoreImg;
+import shop.alien.entity.store.StoreMenu;
+
+public interface StorePlatformImgService extends IService<StoreImg> {
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformMenuService.java

@@ -0,0 +1,79 @@
+package shop.alien.storeplatform.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.StoreMenu;
+import shop.alien.entity.store.vo.StoreMenuVo;
+
+import java.util.List;
+
+/**
+ * 二期-门店推荐 服务类
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+public interface StorePlatformMenuService extends IService<StoreMenu> {
+
+    /**
+     * 获取门店菜单
+     *
+     * @param storeId  门店id
+     * @param dishType 菜品类型, 0:菜单, 1:推荐
+     * @param phoneId  消息标识
+     * @return list
+     */
+    List<StoreMenuVo> getStoreMenu(Integer storeId, Integer dishType, String phoneId);
+
+    /**
+     * 获取菜品详情
+     *
+     * @param id 菜品id
+     * @return StoreMenuVo
+     */
+    StoreMenuVo getMenuInfo(Integer id);
+
+    /**
+     * 新增或修改门店菜单
+     *
+     */
+    R<String> saveOrUpdateMenu(StoreMenu storeMenu);
+
+    /**
+     * 新增或修改门店菜单
+     *
+     */
+    R<String> saveOrUpdateMenus(StoreMenuVo storeMenuVo);
+
+    /**
+     *
+     * 菜品排序
+     */
+    Boolean getSortMenuInfo(StoreMenuVo storeMenuVo);
+
+    /**
+     *
+     * 保存菜品排序
+     */
+    Boolean saveMenuSort(List<StoreMenu> storeMenuList);
+
+    /**
+     *
+     * 删除门店菜单
+     */
+    R deleteMenu(List<Integer> ids, int dishType);
+
+
+
+    StoreMenuVo getMenuCountByStoreId(int storeId);
+
+    /**
+     * 获取用户对该菜品是否点赞
+     *
+     * @param userId  用户id
+     * @param menuId 菜品id
+     * @return boolean
+     */
+    boolean getMenuLikeStatus(String userId, Integer menuId);
+}
+

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformOfficialAlbumService.java

@@ -0,0 +1,16 @@
+package shop.alien.storeplatform.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.store.StoreOfficialAlbum;
+import shop.alien.entity.store.vo.StoreOfficialAlbumVo;
+
+import java.util.List;
+
+/**
+ * 官方相册服务
+ */
+public interface StorePlatformOfficialAlbumService extends IService<StoreOfficialAlbum> {
+    StoreOfficialAlbum createOrUpdateOfficialAlbum(StoreOfficialAlbum storeOfficialAlbum);
+    List<StoreOfficialAlbumVo> getOfficialAlbumList(String storeId);
+    int deleteOfficialAlbum(List<StoreOfficialAlbum> storeOfficialAlbumList);
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformRenovationService.java

@@ -0,0 +1,9 @@
+package shop.alien.storeplatform.service;
+
+import shop.alien.entity.store.vo.StoreMainInfoVo;
+
+public interface StorePlatformRenovationService {
+
+    StoreMainInfoVo getDecorationDetail(Integer id);
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformTagBusinessRelationService.java

@@ -0,0 +1,16 @@
+package shop.alien.storeplatform.service;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.store.TagBusinessRelation;
+
+/**
+ * 标签服务
+ */
+
+public interface StorePlatformTagBusinessRelationService extends IService<TagBusinessRelation> {
+    TagBusinessRelation createTagBusinessRelation(TagBusinessRelation tagBusinessRelation);
+    IPage<TagBusinessRelation> getTagBusinessRelationList(int page, int size, int businessSection, String businessSectionName);
+    int deleteTagBusinessRelation(TagBusinessRelation tagBusinessRelation);
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformTagCategoryService.java

@@ -0,0 +1,22 @@
+package shop.alien.storeplatform.service;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import shop.alien.entity.store.TagCategory;
+import shop.alien.entity.store.vo.TagCategoryVo;
+
+import java.util.List;
+
+/**
+ * 标签服务
+ */
+
+public interface StorePlatformTagCategoryService extends IService<TagCategory> {
+
+    TagCategory createTag(TagCategory tagCategory);
+    IPage<TagCategory> getTagList(int page, int size,String label,String labelType, String labelButtonType);
+    int deleteTag(TagCategory tagCategory);
+    int updateTagCategory(TagCategory tagCategory);
+    List<TagCategoryVo> getBusinessRelationTagList(Integer businessSection);
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/StorePlatformTagRelationService.java

@@ -0,0 +1,14 @@
+package shop.alien.storeplatform.service;
+
+
+import shop.alien.entity.store.TagStoreRelation;
+
+/**
+ * 店铺标签服务接口
+ */
+
+public interface StorePlatformTagRelationService {
+
+    TagStoreRelation createOrUpdateTagStoreRelation(TagStoreRelation tagStoreRelation);
+    TagStoreRelation getTagStoreRelationByStoreId(int storeId);
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformBusinessInfoServiceImpl.java

@@ -0,0 +1,38 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.store.StoreBusinessInfo;
+import shop.alien.mapper.StoreBusinessInfoMapper;
+import shop.alien.storeplatform.service.StorePlatformBusinessInfoService;
+
+import java.util.List;
+
+/**
+ * 二期-门店营业时间 服务实现类
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+@Transactional
+@Service
+public class StorePlatformBusinessInfoServiceImpl extends ServiceImpl<StoreBusinessInfoMapper, StoreBusinessInfo> implements StorePlatformBusinessInfoService {
+
+    /**
+     * 获取门店营业信息
+     *
+     * @param storeId 门店信息
+     * @return list
+     */
+    @Override
+    public List<StoreBusinessInfo> getStoreBusinessInfo(Long storeId) {
+        LambdaQueryWrapper<StoreBusinessInfo> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper
+                .eq(StoreBusinessInfo::getStoreId, storeId)
+                .orderByDesc(StoreBusinessInfo::getCreatedTime);
+        return this.list(lambdaQueryWrapper);
+    }
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformImgServiceImpl.java

@@ -0,0 +1,15 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.store.StoreImg;
+import shop.alien.mapper.StoreImgMapper;
+import shop.alien.storeplatform.service.StorePlatformImgService;
+
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class StorePlatformImgServiceImpl extends ServiceImpl<StoreImgMapper, StoreImg> implements StorePlatformImgService {
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformMenuServiceImpl.java

@@ -0,0 +1,284 @@
+package shop.alien.storeplatform.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.alibaba.nacos.common.utils.CollectionUtils;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import shop.alien.entity.result.R;
+import shop.alien.entity.store.LifeGroupBuyThali;
+import shop.alien.entity.store.LifeLikeRecord;
+import shop.alien.entity.store.StoreImg;
+import shop.alien.entity.store.StoreMenu;
+import shop.alien.entity.store.vo.StoreMenuVo;
+import shop.alien.mapper.LifeGroupBuyThaliMapper;
+import shop.alien.mapper.LifeLikeRecordMapper;
+import shop.alien.mapper.StoreMenuMapper;
+import shop.alien.storeplatform.service.StorePlatformImgService;
+import shop.alien.storeplatform.service.StorePlatformMenuService;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 二期-门店推荐 服务实现类
+ *
+ * @author ssk
+ * @since 2024-12-05
+ */
+@Service
+@RequiredArgsConstructor
+public class StorePlatformMenuServiceImpl extends ServiceImpl<StoreMenuMapper, StoreMenu> implements StorePlatformMenuService {
+
+    private final StoreMenuMapper storeMenuMapper;
+
+    private final LifeLikeRecordMapper lifeLikeRecordMapper;
+
+    private final StorePlatformImgService storeImgService;
+
+    private final LifeGroupBuyThaliMapper lifeGroupBuyThaliMapper;
+
+
+    /**
+     * 获取门店菜单
+     *
+     * @param storeId  门店id
+     * @param dishType 菜品类型, 0:菜单, 1:推荐
+     * @param phoneId  消息标识
+     * @return list
+     */
+    @Override
+    public List<StoreMenuVo> getStoreMenu(Integer storeId, Integer dishType, String phoneId) {
+
+        if (dishType == 0) {
+            List<StoreMenuVo> collect = storeMenuMapper.getStoreMenuList(storeId, null);
+            return collect.stream().sorted(Comparator.comparing(StoreMenuVo::getSort)).collect(Collectors.toList());
+        } else {
+            List<StoreMenuVo> collect = storeMenuMapper.getStoreMenuList(storeId, dishType);
+            collect.forEach(item -> {
+                if (StringUtils.isNotEmpty(phoneId)) {
+                    LambdaQueryWrapper<LifeLikeRecord> query = new LambdaQueryWrapper<>();
+                    query.eq(LifeLikeRecord::getDianzanId, phoneId).eq(LifeLikeRecord::getHuifuId, item.getId());
+                    Integer i = lifeLikeRecordMapper.selectCount(query);
+                    if (i > 0) {
+                        item.setIsLike(1);
+                    } else {
+                        item.setIsLike(0);
+                    }
+                }
+            });
+            return collect.stream().sorted(Comparator.comparing(StoreMenuVo::getSort)).collect(Collectors.toList());
+        }
+    }
+
+    /**
+     * 获取菜品详情
+     *
+     * @param id 菜品id
+     * @return StoreMenuVo
+     */
+    @Override
+    public StoreMenuVo getMenuInfo(Integer id) {
+        return storeMenuMapper.getMenuInfo(id);
+    }
+
+    /**
+     * 新增或修改门店菜品
+     *
+     * @param storeMenu
+     * @return
+     */
+    @Override
+    public R<String> saveOrUpdateMenu(StoreMenu storeMenu) {
+        boolean flag = false;
+        LambdaQueryWrapper<StoreMenu> storeMenuLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        //修改菜品
+        if (storeMenu.getId() != null) {
+            flag = this.updateById(storeMenu);
+            if (!flag) {
+                log.error("菜单修改失败");
+                return R.fail("菜单修改失败");
+            }
+            return R.success("菜单修改成功");
+        } else {//新增菜品
+            if (StringUtils.isEmpty(storeMenu.getDishName())) {
+                return R.fail("请输入菜品名称");
+            }
+            storeMenuLambdaQueryWrapper.eq(StoreMenu::getStoreId, storeMenu.getStoreId());
+            List<StoreMenu> menuList = this.list(storeMenuLambdaQueryWrapper);
+            if (CollectionUtil.isNotEmpty(menuList)) {
+                int maxSort = menuList.stream().map(StoreMenu::getSort).reduce(Integer::max).get();
+                storeMenu.setSort(maxSort + 1);
+            } else {
+                storeMenu.setSort(1);
+            }
+            //保存菜品
+            flag = this.save(storeMenu);
+            if (!flag) {
+                return R.fail("菜品新增失败");
+            }
+        }
+        return R.success("新增菜品成功");
+    }
+
+    /**
+     * 新增或修改门店菜品new
+     *
+     * @param storeMenuVo
+     * @return
+     */
+    @Override
+    public R<String> saveOrUpdateMenus(StoreMenuVo storeMenuVo) {
+        boolean flag = false;
+        LambdaQueryWrapper<StoreMenu> storeMenuLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        int imgId = 0;
+        if (storeMenuVo.getImgId() == null || storeMenuVo.getImgId() == 0) {
+            StoreImg storeImg = new StoreImg();
+            storeImg.setStoreId(storeMenuVo.getStoreId());
+            storeImg.setImgType(7);
+            storeImg.setImgUrl(storeMenuVo.getImgUrl());
+            storeImg.setImgDescription(storeMenuVo.getDishName());
+            storeImgService.saveOrUpdate(storeImg);
+            imgId = storeImg.getId();
+        } else {
+            imgId = storeMenuVo.getImgId();
+        }
+
+        // 封装storeMenu参数
+        StoreMenu storeMenu = new StoreMenu();
+        BeanUtils.copyProperties(storeMenuVo, storeMenu);
+        storeMenu.setImgId(imgId);
+
+        //修改菜品
+        if (storeMenu.getId() != null) {
+            flag = this.updateById(storeMenu);
+            if (!flag) {
+                log.error("菜单修改失败");
+                return R.fail("菜单修改失败");
+            }
+            return R.success("菜单修改成功");
+        } else {
+            //新增菜品
+            // 校验菜品参数
+            if (StringUtils.isEmpty(storeMenu.getDishName())) {
+                return R.fail("请输入菜品名称");
+            }
+
+            storeMenuLambdaQueryWrapper.eq(StoreMenu::getStoreId, storeMenu.getStoreId());
+            List<StoreMenu> menuList = this.list(storeMenuLambdaQueryWrapper);
+            if (CollectionUtil.isNotEmpty(menuList)) {
+                int maxSort = menuList.stream().map(StoreMenu::getSort).reduce(Integer::max).get();
+                storeMenu.setSort(maxSort + 1);
+            } else {
+                storeMenu.setSort(1);
+            }
+            //保存菜品
+            flag = this.save(storeMenu);
+            if (!flag) {
+                return R.fail("菜品新增失败");
+            }
+        }
+        return R.success("新增菜品成功");
+    }
+
+
+    /**
+     * 菜品排序信息
+     *
+     * @param storeMenuVo
+     * @return
+     */
+    @Override
+    public Boolean getSortMenuInfo(StoreMenuVo storeMenuVo) {
+        boolean flag = false;
+        if (CollectionUtil.isNotEmpty(storeMenuVo.getSortList())) {
+            for (int i = 0; i < storeMenuVo.getSortList().size(); i++) {
+                LambdaQueryWrapper<StoreMenu> lambdaQueryWrapper = new LambdaQueryWrapper();
+                lambdaQueryWrapper.eq(StoreMenu::getId, storeMenuVo.getSortList().get(i).getId());
+                StoreMenu storeMenu = this.getOne(lambdaQueryWrapper);
+                storeMenu.setSort(i + 1);
+                flag = this.updateById(storeMenu);
+            }
+        }
+        return flag;
+    }
+
+    @Override
+    public Boolean saveMenuSort(List<StoreMenu> storeMenuList) {
+        return this.updateBatchById(storeMenuList);
+    }
+
+    /**
+     * 删除菜品或推荐菜 根据类型区分
+     *
+     * @param ids
+     * @param dishType 0:菜品 1:推荐菜
+     * @return
+     */
+    @Override
+    public R deleteMenu(List<Integer> ids, int dishType) {
+        QueryWrapper<StoreMenu> queryWrapperMenu = new QueryWrapper<>();
+        boolean flag = false;
+        if (dishType == 0) {
+            List<LifeGroupBuyThali> lifeGroupBuyThaliList = lifeGroupBuyThaliMapper.selectList(new LambdaQueryWrapper<LifeGroupBuyThali>().in(LifeGroupBuyThali::getDetailId, ids));
+            if (CollectionUtil.isNotEmpty(lifeGroupBuyThaliList)) {
+                return R.fail("该菜品已被团购套餐引用，不能删除");
+            }
+            flag = this.removeByIds(ids);
+        } else {
+            queryWrapperMenu.in("id", ids);
+            List<StoreMenu> storeMenuList = baseMapper.selectList(queryWrapperMenu);
+            storeMenuList.forEach(item -> {
+                item.setDishType(0);
+                this.updateById(item);
+            });
+            flag = true;
+        }
+        if (!flag) {
+            return R.fail("删除失败");
+        }
+        return R.success("删除成功");
+    }
+    @Override
+    public StoreMenuVo getMenuCountByStoreId(int storeId) {
+        StoreMenuVo storeMenuVo = new StoreMenuVo();
+        LambdaUpdateWrapper<StoreMenu> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.eq(StoreMenu::getStoreId, storeId);
+        updateWrapper.eq(StoreMenu::getDeleteFlag, 0);
+        List<StoreMenu> storeMenuList = storeMenuMapper.selectList(updateWrapper);
+        if (CollectionUtils.isNotEmpty(storeMenuList)) {
+            storeMenuVo.setMenuCount(storeMenuList.size());
+            Map<Integer, List<StoreMenu>> groupByDishType = storeMenuList.stream()
+                    .collect(Collectors.groupingBy(StoreMenu::getDishType));
+            List<StoreMenu> suggestList = groupByDishType.get(1);
+            if (CollectionUtils.isNotEmpty(suggestList)) {
+                storeMenuVo.setSuggestCount(suggestList.size());
+            } else {
+                storeMenuVo.setSuggestCount(0);
+            }
+        } else {
+            storeMenuVo.setMenuCount(0);
+            storeMenuVo.setSuggestCount(0);
+        }
+        return storeMenuVo;
+    }
+
+    /**
+     * 获取用户对该菜品是否点赞
+     *
+     * @param userId 用户id
+     * @param menuId 菜品id
+     * @return boolean
+     */
+    @Override
+    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;
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformOfficialAlbumServiceImpl.java

@@ -0,0 +1,101 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.alibaba.excel.util.CollectionUtils;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.entity.store.StoreImg;
+import shop.alien.entity.store.StoreOfficialAlbum;
+import shop.alien.entity.store.vo.StoreOfficialAlbumVo;
+import shop.alien.mapper.StoreImgMapper;
+import shop.alien.mapper.StoreOfficialAlbumMapper;
+import shop.alien.storeplatform.service.StorePlatformOfficialAlbumService;
+import shop.alien.storeplatform.util.CommonConstant;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Transactional
+@Service
+@RequiredArgsConstructor
+public class StorePlatformOfficialAlbumServiceImpl extends ServiceImpl<StoreOfficialAlbumMapper, StoreOfficialAlbum> implements StorePlatformOfficialAlbumService {
+
+    private final StoreOfficialAlbumMapper storeOfficialAlbumMapper;
+    private final StoreImgMapper storeImgMapper;
+
+    /**
+     * 创建官方相册
+     *
+     * @param storeOfficialAlbum 官方相册信息
+     * @return storeOfficialAlbum 官方相册信息
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public StoreOfficialAlbum createOrUpdateOfficialAlbum(StoreOfficialAlbum storeOfficialAlbum) {
+        Integer id= storeOfficialAlbum.getId();
+        if (id!=null && id > 0) {
+            boolean updateSuccess = storeOfficialAlbumMapper.updateById(storeOfficialAlbum) > 0;
+            if (!updateSuccess) {
+                throw new RuntimeException("更新官方相册失败");
+            }
+        } else {
+            boolean insertSuccess = storeOfficialAlbumMapper.insert(storeOfficialAlbum) > 0;
+            if (!insertSuccess) {
+                throw new RuntimeException("插入官方相册失败");
+            }
+        }
+        return storeOfficialAlbum;
+    }
+
+    /**
+     * 根据storeId查询官方相册列表
+     *
+     * @param storeId 店铺ID
+     * @return List<StoreOfficialAlbumVo> 官方相册列表
+     */
+    @Override
+    public List<StoreOfficialAlbumVo> getOfficialAlbumList(String storeId) {
+        if(StringUtils.isNotBlank(storeId)) {
+            //查询出店铺官方相册img数量并更新
+            List<StoreOfficialAlbum> storeOfficialAlbumList = storeOfficialAlbumMapper.getStoreOfficialAlbumImgCount(Integer.parseInt(storeId));
+            this.updateBatchById(storeOfficialAlbumList);
+
+            // 查询官方相册列表
+            return storeOfficialAlbumMapper.getStoreOfficialAlbumList(Integer.parseInt(storeId));
+        }
+        return Collections.emptyList();
+    }
+
+    /**
+     * 根据storeId查询官方相册列表
+     *
+     * @param storeOfficialAlbumList 根据官方相册信息删除官方相册及图片
+     * @return result 删除结果
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public int deleteOfficialAlbum(List<StoreOfficialAlbum> storeOfficialAlbumList) {
+
+        // 校验官方相册列表
+        if (storeOfficialAlbumList == null || storeOfficialAlbumList.isEmpty()) {
+            return CommonConstant.ERROR_CODE_INVALID_PARAMS;
+        }
+        List<Integer> albumIds =storeOfficialAlbumList.stream().map(StoreOfficialAlbum::getId).collect(Collectors.toList());
+        if (CollectionUtils.isEmpty(albumIds)) {
+            return CommonConstant.ERROR_CODE_INVALID_PARAMS;
+        }
+
+        // 删除相册
+        storeOfficialAlbumMapper.deleteBatchIds(albumIds);
+        // 删除图片（批量删除）
+        LambdaUpdateWrapper<StoreImg> wrapper = new LambdaUpdateWrapper<StoreImg>()
+                .in(StoreImg::getBusinessId, albumIds)
+                .eq(StoreImg::getImgType, CommonConstant.STORE_IMG_ALBUM);
+        storeImgMapper.delete(wrapper);
+        return CommonConstant.ERROR_CODE_VALID_PARAMS;
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformRenovationServiceImpl.java

@@ -0,0 +1,77 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.stereotype.Service;
+import shop.alien.entity.store.*;
+import shop.alien.entity.store.vo.StoreMainInfoVo;
+import shop.alien.mapper.*;
+import shop.alien.storeplatform.service.StorePlatformRenovationService;
+
+import java.text.SimpleDateFormat;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@RefreshScope
+public class StorePlatformRenovationServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo> implements StorePlatformRenovationService {
+
+    private final StoreInfoMapper storeInfoMapper;
+    private final StoreLabelMapper storeLabelMapper;
+    private final StoreBusinessInfoMapper storeBusinessInfoMapper;
+    private final StoreImgMapper storeImgMapper;
+
+    @Override
+    public StoreMainInfoVo getDecorationDetail(Integer id) {
+        StoreInfo storeInfo = storeInfoMapper.selectById(id);
+        StoreMainInfoVo storeMainInfoVo = storeInfoMapper.getStoreInfo(id);
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+        String expirationDate = sdf.format(storeMainInfoVo.getExpirationTime());
+        storeMainInfoVo.setExpirationDate(expirationDate);
+        //审核通过给前台反显未提交
+        if (storeMainInfoVo.getRenewContractStatus() == 1) {
+            storeMainInfoVo.setRenewContractStatus(0);
+        }
+        if (storeMainInfoVo.getStoreStatus() == -1) {
+            LocalDateTime localDateTime = storeMainInfoVo.getLogoutTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
+            LocalDateTime future = localDateTime.plusDays(7);
+            LocalDateTime now = LocalDateTime.now();
+            Duration duration = Duration.between(now, future);
+            long correct = duration.toMillis();
+            storeMainInfoVo.setCountdown(correct);
+        }
+        //存入门店地址
+        storeMainInfoVo.setStoreAddress(storeInfo.getStoreAddress());
+        //经营种类
+        if (storeInfo.getBusinessTypes() != null) {
+            String[] strings = storeInfo.getBusinessTypes().split(",");
+            storeMainInfoVo.setBusinessTypesList(Arrays.stream(strings).collect(Collectors.toList()));
+        }
+        //门店标签
+        storeMainInfoVo.setStoreLabel(storeLabelMapper.selectOne(new LambdaQueryWrapper<StoreLabel>().eq(StoreLabel::getStoreId, id)));
+        //营业时间
+        List<StoreBusinessInfo> storeBusinessInfoList = storeBusinessInfoMapper.selectList(new LambdaQueryWrapper<StoreBusinessInfo>().eq(StoreBusinessInfo::getStoreId, id));
+        storeMainInfoVo.setStoreBusinessInfo(storeBusinessInfoList);
+        //营业执照
+        storeMainInfoVo.setBusinessLicenseList(storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 14).eq(StoreImg::getStoreId, id)));
+        //合同照片
+        storeMainInfoVo.setContractList(storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 15).eq(StoreImg::getStoreId, id)));
+        //经营许可证图片照片
+        storeMainInfoVo.setFoodLicenceList(storeImgMapper.selectList(new LambdaQueryWrapper<StoreImg>().eq(StoreImg::getImgType, 25).eq(StoreImg::getStoreId, id)));
+        //是否连锁
+        String isChain = (storeInfo.getIsChain() == 0) ? "否" : "是";
+        storeMainInfoVo.setIsChainStr(isChain);
+        storeMainInfoVo.setFoodLicenceExpirationTime(storeInfo.getFoodLicenceExpirationTime());
+        return storeMainInfoVo;
+    }
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformTagBusinessRelationServiceImpl.java

@@ -0,0 +1,62 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.alibaba.nacos.common.utils.CollectionUtils;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.stereotype.Service;
+import shop.alien.entity.store.TagBusinessRelation;
+import shop.alien.mapper.TagBusinessRelationMapper;
+import shop.alien.storeplatform.service.StorePlatformTagBusinessRelationService;
+
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class StorePlatformTagBusinessRelationServiceImpl extends ServiceImpl<TagBusinessRelationMapper, TagBusinessRelation> implements StorePlatformTagBusinessRelationService {
+    public final TagBusinessRelationMapper tagBusinessRelationMapper;
+
+    @Override
+    public TagBusinessRelation createTagBusinessRelation(TagBusinessRelation tagBusinessRelation) {
+
+        // 校验同一层级是否存在相同的标签
+        List<TagBusinessRelation> tagCategoryList = tagBusinessRelationMapper.selectList(new LambdaQueryWrapper<TagBusinessRelation>().eq(TagBusinessRelation::getTagId, tagBusinessRelation.getTagId()).eq(TagBusinessRelation::getBusinessSection, tagBusinessRelation.getBusinessSection()));
+        if(CollectionUtils.isNotEmpty(tagCategoryList)){
+            throw new IllegalArgumentException("标签已经存在");
+        }
+
+        // 将数据存储到数据库中
+        log.info("标签创建, 请求参数: {}", tagBusinessRelation);
+        int result = tagBusinessRelationMapper.insert(tagBusinessRelation);
+        log.info("标签创建, 结果: {}", result);
+        // 清除相关缓存
+        return tagBusinessRelation;
+    }
+
+    @Override
+    public IPage<TagBusinessRelation> getTagBusinessRelationList(int page, int size, int businessSection, String businessSectionName) {
+        IPage<TagBusinessRelation> iPage = new Page<>(page, size);
+        LambdaQueryWrapper<TagBusinessRelation> tagCategoryLambdaQueryWrapper = new LambdaQueryWrapper<TagBusinessRelation>();
+        tagCategoryLambdaQueryWrapper.eq(TagBusinessRelation::getDeleteFlag, 0);
+        if(businessSection > 0) {
+            tagCategoryLambdaQueryWrapper.eq(TagBusinessRelation::getTagId, businessSection);
+        }
+        if(StringUtils.isNotBlank(businessSectionName)) {
+            tagCategoryLambdaQueryWrapper.like(TagBusinessRelation::getBusinessSectionName,businessSectionName);
+        }
+        tagCategoryLambdaQueryWrapper.orderByDesc(TagBusinessRelation::getCreatedTime);
+        return tagBusinessRelationMapper.selectPage(iPage,tagCategoryLambdaQueryWrapper);
+    }
+    @Override
+    public int deleteTagBusinessRelation(TagBusinessRelation tagBusinessRelation) {
+        if(tagBusinessRelation == null ||tagBusinessRelation.getId() == null){
+            return 0;
+        }
+        return tagBusinessRelationMapper.deleteById(tagBusinessRelation.getId());
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformTagCategoryServiceImpl.java

@@ -0,0 +1,200 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shop.alien.config.redis.BaseRedisService;
+import shop.alien.entity.store.TagCategory;
+import shop.alien.entity.store.vo.LabelButtonOptionVo;
+import shop.alien.entity.store.vo.TagCategoryVo;
+import shop.alien.mapper.TagCategoryMapper;
+import shop.alien.storeplatform.service.StorePlatformTagCategoryService;
+
+import java.util.Collections;
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class StorePlatformTagCategoryServiceImpl extends ServiceImpl<TagCategoryMapper, TagCategory> implements StorePlatformTagCategoryService {
+
+    public final TagCategoryMapper tagCategoryMapper;
+    private final BaseRedisService baseRedisService;
+    private static final String TAG_TREE_CACHE_KEY = "tag:tree";
+
+    @Override
+    public TagCategory createTag(TagCategory tagCategory) {
+
+        // 校验同一层级是否存在相同的标签
+//        List<TagCategory> tagCategoryList = tagCategoryMapper.selectList(new LambdaQueryWrapper<TagCategory>().eq(TagCategory::getLabelType, tagCategory.getLabelType()).eq(TagCategory::getTagName, tagCategory.getTagName()));
+//        if(CollectionUtils.isNotEmpty(tagCategoryList)){
+//            throw new IllegalArgumentException("标签已经存在");
+//        }
+
+        // 将数据存储到数据库中
+        log.info("标签创建, 请求参数: {}", tagCategory);
+        int result = tagCategoryMapper.insert(tagCategory);
+        log.info("标签创建, 结果: {}", result);
+        // 清除相关缓存
+//        baseRedisService.delete(TAG_TREE_CACHE_KEY);
+        return tagCategory;
+    }
+
+    @Override
+    public IPage<TagCategory> getTagList(int page, int size,String label,String labelType, String labelButtonType) {
+        IPage<TagCategory> iPage = new Page<>(page, size);
+        LambdaQueryWrapper<TagCategory> tagCategoryLambdaQueryWrapper = new LambdaQueryWrapper<TagCategory>();
+        tagCategoryLambdaQueryWrapper.eq(TagCategory::getDeleteFlag, 0);
+        if(StringUtils.isNotBlank(label)){
+            tagCategoryLambdaQueryWrapper.like(TagCategory::getTagName,label);
+        }
+        if(StringUtils.isNotBlank(labelType)){
+            tagCategoryLambdaQueryWrapper.eq(TagCategory::getLabelType, labelType);
+        }
+        if(StringUtils.isNotBlank(labelButtonType)){
+            tagCategoryLambdaQueryWrapper.eq(TagCategory::getLabelButtonType, labelButtonType);
+        }
+        tagCategoryLambdaQueryWrapper.orderByDesc(TagCategory::getCreatedTime);
+        return tagCategoryMapper.selectPage(iPage,tagCategoryLambdaQueryWrapper);
+    }
+
+//    @Override
+//    public List<TagCategory> getTagTree() {
+//        // 缓存获取
+//
+//        List<TagCategory> tagCategoryTree = new ArrayList<>();
+//        try {
+//            tagCategoryTree = baseRedisService.getList(TAG_TREE_CACHE_KEY, TagCategory.class);
+//        } catch (JsonProcessingException e) {
+//            log.error("StoreTagServiceImpl-getTagTree获取缓存异常: ", e);
+//            throw new RuntimeException(e);
+//        }
+//        if (CollectionUtils.isNotEmpty(tagCategoryTree)) {
+//            return tagCategoryTree;
+//        }
+//
+//        // 从数据库获取未删除的所有标签
+//        LambdaQueryWrapper<TagCategory> queryWrapper = new LambdaQueryWrapper<>();
+//        queryWrapper.like(TagCategory::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);
+//        List<TagCategory> allTags = tagCategoryMapper.selectList(queryWrapper);
+//
+//        // 构建树形结构
+//        tagCategoryTree = buildTagTree(allTags);
+//
+//        // 缓存结果
+//        if (CollectionUtils.isNotEmpty(tagCategoryTree)) {
+//            try {
+//                baseRedisService.storeList(TAG_TREE_CACHE_KEY, tagCategoryTree);
+//            } catch (JsonProcessingException e) {
+//                log.error("StoreTagServiceImpl-getTagTree存储缓存异常: ", e);
+//                throw new RuntimeException(e);
+//            }
+//        }
+//
+//        return tagCategoryTree;
+//    }
+
+    @Override
+    public int deleteTag(TagCategory tagCategory) {
+        if(tagCategory == null ||tagCategory.getId() == null){
+            return 0;
+        }
+
+        int deleteTagResult = tagCategoryMapper.deleteById(tagCategory.getId());
+        if (deleteTagResult > 0) {
+            baseRedisService.delete(TAG_TREE_CACHE_KEY);
+        }
+        return deleteTagResult;
+    }
+
+    @Override
+    public int updateTagCategory(TagCategory tagCategory) {
+        if(tagCategory == null){
+            return 0;
+        }
+        int updateResult = tagCategoryMapper.updateById(tagCategory);
+        if (updateResult > 0){
+            baseRedisService.delete(TAG_TREE_CACHE_KEY);
+        }
+        return updateResult;
+    }
+
+    @Override
+    public List<TagCategoryVo> getBusinessRelationTagList(Integer businessSection) {
+        if(businessSection!=null){
+            List<TagCategoryVo> tagCategoryVoList = tagCategoryMapper.getBusinessRelationTagList(businessSection);
+            return getCategories(tagCategoryVoList);
+        }
+        return Collections.emptyList();
+    }
+
+
+    private static List<TagCategoryVo> getCategories(List<TagCategoryVo> tagCategoryVoList) {
+        tagCategoryVoList.forEach(tagCategoryVo -> {
+            String labelButtonOptionOne = tagCategoryVo.getLabelButtonOptionOne();
+            String labelButtonOptionTwo = tagCategoryVo.getLabelButtonOptionTwo();
+            if(StringUtils.isNotBlank(labelButtonOptionOne)){
+                try {
+                    ObjectMapper objectMapper = new ObjectMapper();
+                    List<LabelButtonOptionVo> tagValueVoList1 = objectMapper.readValue(labelButtonOptionOne,
+                            new TypeReference<List<LabelButtonOptionVo>>() {});
+                    tagCategoryVo.setLabelButtonOption1(tagValueVoList1);
+                } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            if(StringUtils.isNotBlank(labelButtonOptionTwo)){
+                try {
+                    ObjectMapper objectMapper = new ObjectMapper();
+                    List<LabelButtonOptionVo> tagValueVoList2 = objectMapper.readValue(labelButtonOptionTwo,
+                            new TypeReference<List<LabelButtonOptionVo>>() {});
+                    tagCategoryVo.setLabelButtonOption2(tagValueVoList2);
+                } catch (JsonProcessingException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+        return tagCategoryVoList;
+    }
+
+
+
+
+    /**
+     * 构造树形结构方法
+     *
+     * @param allTags 所有标签列表
+     * @return 构造完成后的标签列表
+     */
+//    private List<TagCategory> buildTagTree(List<TagCategory> allTags) {
+//        Map<Integer, List<TagCategory>> tagMap = allTags.stream()
+//                .collect(Collectors.groupingBy(TagCategory::getParentTagId));
+//        List<TagCategory> rootTags = tagMap.getOrDefault(0, Collections.emptyList());
+//        rootTags.forEach(tag -> buildChildren(tag, tagMap));
+//        return rootTags;
+//    }
+
+    /**
+     * 构造树形结构方法
+     *
+     * @param parentTagCategory 父标签
+     * @param tagMap 父标签ID分组MAP
+     */
+//    private void buildChildren(TagCategory parentTagCategory, Map<Integer, List<TagCategory>> tagMap) {
+//        List<TagCategory> children = tagMap.getOrDefault(parentTagCategory.getId(), Collections.emptyList());
+//        parentTagCategory.setChildrenTag(children);
+//        children.forEach(child -> buildChildren(child, tagMap));
+//    }
+
+
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/service/impl/StorePlatformTagRelationServiceImpl.java

@@ -0,0 +1,55 @@
+package shop.alien.storeplatform.service.impl;
+
+import com.alibaba.nacos.common.utils.CollectionUtils;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import shop.alien.config.redis.BaseRedisService;
+import shop.alien.entity.store.TagStoreRelation;
+import shop.alien.mapper.TagStoreRelationMapper;
+import shop.alien.storeplatform.service.StorePlatformTagRelationService;
+
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class StorePlatformTagRelationServiceImpl implements StorePlatformTagRelationService {
+    public final TagStoreRelationMapper tagStoreRelationMapper;
+    private final BaseRedisService baseRedisService;
+    private static final String TAG_STORE_CACHE_KEY = "tag_store";
+    @Override
+    public TagStoreRelation createOrUpdateTagStoreRelation(TagStoreRelation tagStoreRelation) {
+        // 校验同一层级是否存在相同的店铺标签信息
+        List<TagStoreRelation> tagStoreRelationList = tagStoreRelationMapper.selectList(new LambdaQueryWrapper<TagStoreRelation>().eq(TagStoreRelation::getStoreId, tagStoreRelation.getStoreId()));
+        if(CollectionUtils.isNotEmpty(tagStoreRelationList)){
+            // 店铺标签信息已经存在，进行更新操作
+            tagStoreRelationMapper.updateById(tagStoreRelation);
+        } else {
+            // 将数据存储到数据库中
+            tagStoreRelationMapper.insert(tagStoreRelation);
+        }
+        return tagStoreRelation;
+    }
+
+    @Override
+    public TagStoreRelation getTagStoreRelationByStoreId(int storeId) {
+        TagStoreRelation tagStoreRelation = new TagStoreRelation();
+        LambdaQueryWrapper<TagStoreRelation> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(TagStoreRelation::getStoreId, storeId);
+        wrapper.eq(TagStoreRelation::getDeleteFlag,0);
+        List<TagStoreRelation> tagStoreRelationList = tagStoreRelationMapper.selectList(wrapper);
+        if (CollectionUtils.isNotEmpty(tagStoreRelationList)) {
+            tagStoreRelation = tagStoreRelationList.get(0);
+        }
+        return tagStoreRelation;
+    }
+
+    /**
+     * 构建 Redis 缓存 Key
+     */
+    private String buildTagStoreCacheKey(int storeId) {
+        return TAG_STORE_CACHE_KEY + ":" + storeId;
+    }
+}

alien-store-platform/src/main/java/shop/alien/storeplatform/util/CommonConstant.java

@@ -0,0 +1,58 @@
+package shop.alien.storeplatform.util;
+
+/**
+ * 通用常量配置
+ * @author zhangchen
+ * @since 2025/7/1
+ */
+public class CommonConstant {
+
+    /**
+     * 是否删除，0：未删除，2：已删除
+     */
+    public static final Integer DELETE_FLAG_UNDELETE = 0;
+    public static final Integer DELETE_FLAG_DELETED = 1;
+
+    /**
+     * 优惠券类型，1-代金券  2-团购（套餐）
+     */
+    public static final Integer LIFE_COUPON_TYPE = 1;
+    public static final Integer LIFE_GROUP_TYPE = 2;
+
+    /**
+     * 优惠券状态，-1：待审核，-2：审核不通过，0：未使用，1：使用中，2：暂停，3：已结束
+     */
+    public static final Integer LIFE_COUPON_STATUS_PENDING_APPROVAL = -1;
+    public static final Integer LIFE_COUPON_STATUS_REJECTED = -2;
+    public static final Integer LIFE_COUPON_STATUS_UNUSED = 0;
+    public static final Integer LIFE_COUPON_STATUS_USING = 1;
+    public static final Integer LIFE_COUPON_STATUS_PAUSE = 2;
+    public static final Integer LIFE_COUPON_STATUS_END = 3;
+
+    /**
+     * 新建/更新返回值，0：失败，1：成功
+     */
+    public static final Integer ERROR_CODE_VALID_PARAMS = 1;
+    public static final Integer ERROR_CODE_INVALID_PARAMS = 0;
+
+    /**
+     * 标签类型 1:套餐, 2:门店
+     */
+    public static final String LABEL_TYPE_MENU = "1";
+    public static final String LABEL_TYPE_SHOP = "2";
+
+    /**
+     * 图片类型，0:其他, 1:入口图, 2:相册, 3:菜品, 4:环境, 5:价目表, 6:推荐菜, 7:菜单, 8:用户评论, 9:商家申诉,10:商家头像,11:店铺轮播图,12:联名卡图片,13:动态折扣，14：营业执照，15：合同照片,17:打卡广场小人图片 18: 二手商品发布图片, 19:二手商品与用户举报图片
+     */
+    public static final Integer STORE_IMG_OTHER = 1;
+    public static final Integer STORE_IMG_ALBUM = 2;
+
+    public static final String STORE_DICT_TYPENAME = "storeArea,businessStatus,week,specialDate,business_section,fine_food";
+
+    /**
+     * 门店经营许可证到期状态管理 0:已到期 1:即将到期 2:未到期
+     */
+    public static final String FOOD_LICENCE_EXPIRE_STATUS = "0";
+    public static final String FOOD_LICENCE_ABOUT_TO_EXPIRE_STATUS = "1";
+    public static final String FOOD_LICENCE_NOT_EXPIRED_STATUS = "2";
+}