admin1/jiangchengfeiyi-houduan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新了写真预约模块

Browse Source
This commit is contained in:
chen-xin-zhi 2025-02-15 13:38:50 +08:00
parent 68dc85d1bf
commit 930505100c
36 changed files with 1068 additions and 1020 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
src/main/java/com/cultural/heritage/controller/book/ClothesGradeController.java
View File

@ -1,148 +0,0 @@
package com.cultural.heritage.controller.book;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.cultural.heritage.annotation.AuthCheck;
import com.cultural.heritage.common.BaseResponse;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.common.ResultUtils;
import com.cultural.heritage.constant.UserConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.model.dto.CommonRequest;
import com.cultural.heritage.model.dto.clothesgrade.ClothesGradeAddRequest;
import com.cultural.heritage.model.dto.clothesgrade.ClothesGradeUpdateRequest;
import com.cultural.heritage.model.entity.ClothesGrade;
import com.cultural.heritage.model.entity.ClothesInfo;
import com.cultural.heritage.model.vo.clothesgrade.ClothesGradeVO;
import com.cultural.heritage.service.book.ClothesGradeService;
import com.cultural.heritage.service.book.ClothesInfoService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
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.List;
@RestController
@RequestMapping("/clothesGrade")
@Slf4j
@Tag(name = "服装等级管理模块")
public class ClothesGradeController {
@Resource
private ClothesGradeService clothesGradeService;
@Resource
private ClothesInfoService clothesInfoService;
/**
* Web端管理员添加服装等级
* @param clothesGradeAddRequest 服装等级添加请求体
* @return 是否添加成功
*/
@PostMapping("/add")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员添加服装等级", description = "参数：服装等级添加请求体，权限：管理员(admin, boss)，方法名：addClothesGrade")
public BaseResponse<Long> addClothesGrade(@RequestBody ClothesGradeAddRequest clothesGradeAddRequest) {
if (clothesGradeAddRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
ClothesGrade clothesGrade = new ClothesGrade();
BeanUtils.copyProperties(clothesGradeAddRequest, clothesGrade);
// 校验
clothesGradeService.validClothesGrade(clothesGrade, false);
boolean save = clothesGradeService.save(clothesGrade);
ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR);
return ResultUtils.success(clothesGrade.getId());
}
/**
* Web端管理员更新服装等级
* @param clothesGradeUpdateRequest 服装等级更新请求体
* @return 是否更新成功
*/
@PostMapping("/update")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员更新服装等级", description = "参数：服装等级更新请求体，权限：管理员(admin, boss)，方法名：updateClothesGrade")
public BaseResponse<Boolean> updateClothesGrade(@RequestBody ClothesGradeUpdateRequest clothesGradeUpdateRequest) {
if (clothesGradeUpdateRequest == null || clothesGradeUpdateRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
// 获取原有服装等级名称
Long id = clothesGradeUpdateRequest.getId();
ClothesGrade originClothesGrade = clothesGradeService.getById(id);
String originClothesType = originClothesGrade.getClothesType();
// 获取目标服装等级名称
String targetClothesType = clothesGradeUpdateRequest.getClothesType();
// 判空
if (StringUtils.isAnyBlank(originClothesType, targetClothesType)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "服装等级参数为空");
}
// 更新原有服装等级下所有服装的等级
UpdateWrapper<ClothesInfo> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("clothesType", originClothesType).set("clothesType", targetClothesType);
boolean update = clothesInfoService.update(updateWrapper);
ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "服装等级名称更新失败");
// 更新服装等级信息
ClothesGrade clothesGrade = new ClothesGrade();
BeanUtils.copyProperties(clothesGradeUpdateRequest, clothesGrade);
// 校验
clothesGradeService.validClothesGrade(clothesGrade, true);
boolean result = clothesGradeService.updateById(clothesGrade);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "服装等级信息更新失败");
return ResultUtils.success(true);
}
/**
* 删除服装等级
* @param commonRequest 服装等级删除请求体
* @return 是否删除成功
*/
@PostMapping("/delete")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员删除服装等级", description = "参数：服装等级删除请求体，权限：管理员(admin, boss)，方法名：deleteClothesGrade")
public BaseResponse<Boolean> deleteClothesGrade(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
// 删除等级服装之前，先删除该等级服装下的所有商品
clothesGradeService.deleteCurrentAllClothes(id);
boolean result = clothesGradeService.removeById(id);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
return ResultUtils.success(true);
}
/**
* 查询所有服装等级
* @return 服装等级列表
*/
@PostMapping("/list")
@Operation(summary = "Web端和小程序端查询服装等级", description = "参数：无，权限：所有人，方法名：listClothesGrade")
public BaseResponse<List<ClothesGradeVO>> listClothesGrade() {
List<ClothesGrade> clothesGradeList = clothesGradeService.list();
List<ClothesGradeVO> clothesGradeVOS = clothesGradeList.stream().map(clothesGrade -> {
ClothesGradeVO clothesGradeVO = new ClothesGradeVO();
BeanUtils.copyProperties(clothesGrade, clothesGradeVO);
return clothesGradeVO;
}).toList();
return ResultUtils.success(clothesGradeVOS);
}
}

197
src/main/java/com/cultural/heritage/controller/book/ClothesInfoController.java
View File

@ -1,197 +0,0 @@
package com.cultural.heritage.controller.book;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cultural.heritage.annotation.AuthCheck;
import com.cultural.heritage.common.BaseResponse;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.common.ResultUtils;
import com.cultural.heritage.constant.UserConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.model.dto.CommonRequest;
import com.cultural.heritage.model.dto.clothesinfo.ClothesInfoAddRequest;
import com.cultural.heritage.model.dto.clothesinfo.ClothesInfoQueryRequest;
import com.cultural.heritage.model.dto.clothesinfo.ClothesInfoUpdateRequest;
import com.cultural.heritage.model.entity.ClothesGrade;
import com.cultural.heritage.model.entity.ClothesInfo;
import com.cultural.heritage.model.vo.clothesinfo.ClothesInfoLabelVO;
import com.cultural.heritage.model.vo.clothesinfo.ClothesInfoVO;
import com.cultural.heritage.service.book.ClothesGradeService;
import com.cultural.heritage.service.book.ClothesInfoService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/clothesInfo")
@Slf4j
@Tag(name = "服装信息管理模块")
public class ClothesInfoController {
@Resource
private ClothesInfoService clothesInfoService;
@Resource
private ClothesGradeService clothesGradeService;
/**
* 添加服装
* @param clothesInfoAddRequest 服装添加请求体
* @return 服装的id
*/
@PostMapping("/add")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员添加服装", description = "参数：服装添加请求体，权限：管理员(admin, boss)，方法名：addClothesInfo")
public BaseResponse<Long> addClothesInfo(@RequestBody ClothesInfoAddRequest clothesInfoAddRequest) {
if (clothesInfoAddRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
ClothesInfo clothesInfo = new ClothesInfo();
BeanUtils.copyProperties(clothesInfoAddRequest, clothesInfo);
// 校验
clothesInfoService.validClothesInfo(clothesInfo, false);
boolean result = clothesInfoService.save(clothesInfo);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
return ResultUtils.success(clothesInfo.getId());
}
/**
* 更新服装
* @param clothesInfoUpdateRequest 服装更新请求体
* @return 是否更新成功
*/
@PostMapping("/update")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员更新服装", description = "参数：服装更新请求体，权限：管理员(admin, boss)，方法名：updateClothesInfo")
public BaseResponse<Boolean> updateClothesInfo(@RequestBody ClothesInfoUpdateRequest clothesInfoUpdateRequest) {
if (clothesInfoUpdateRequest == null || clothesInfoUpdateRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
ClothesInfo clothesInfo = new ClothesInfo();
BeanUtils.copyProperties(clothesInfoUpdateRequest, clothesInfo);
// 校验
clothesInfoService.validClothesInfo(clothesInfo, true);
boolean result = clothesInfoService.updateById(clothesInfo);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
return ResultUtils.success(true);
}
/**
* 删除服装
* @param commonRequest 服装删除请求体
* @return 是否删除成功
*/
@PostMapping("/delete")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员删除服装", description = "参数：服装删除请求体，权限：管理员(admin, boss)，方法名：deleteClothesInfo")
public BaseResponse<Boolean> deleteClothesInfo(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
boolean result = clothesInfoService.removeById(id);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
return ResultUtils.success(true);
}
/**
* 分页查询服装列表
* @param clothesInfoQueryRequest 服装查询请求体
* @return 服装列表
*/
@PostMapping("/list/page")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员分页查询服装", description = "参数：服装删除请求体，权限：管理员(admin, boss)，方法名：deleteClothesInfo")
public BaseResponse<Page<ClothesInfoVO>> listClothesInfoByPage(@RequestBody ClothesInfoQueryRequest clothesInfoQueryRequest) {
if (clothesInfoQueryRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
long current = clothesInfoQueryRequest.getCurrent();
long pageSize = clothesInfoQueryRequest.getPageSize();
QueryWrapper<ClothesInfo> queryWrapper = clothesInfoService.getQueryWrapper(clothesInfoQueryRequest);
Page<ClothesInfo> page = clothesInfoService.page(new Page<>(current, pageSize), queryWrapper);
// 封装服装类VO
List<ClothesInfo> records = page.getRecords();
List<ClothesInfoVO> clothesInfoVOS = records.stream().map(clothesInfo -> {
ClothesInfoVO clothesInfoVO = new ClothesInfoVO();
BeanUtils.copyProperties(clothesInfo, clothesInfoVO);
return clothesInfoVO;
}).toList();
Page<ClothesInfoVO> voPage = new Page<>();
voPage.setRecords(clothesInfoVOS);
voPage.setTotal(page.getTotal());
voPage.setCurrent(page.getCurrent());
voPage.setSize(page.getSize());
voPage.setPages(page.getPages());
return ResultUtils.success(voPage);
}
/**
* 小程序端用户根据服装等级id查询服装标签
* @param commonRequest 服装等级id
* @return 当前等级下的服装列表标签
*/
@PostMapping("/list/label")
@Operation(summary = "小程序端用户根据服装等级id查询服装标签", description = "参数：服装等级id，权限：所有人，方法名：listClothesInfoLabel")
public BaseResponse<List<ClothesInfoLabelVO>> listClothesInfoLabel(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
ClothesGrade clothesGrade = clothesGradeService.getById(id);
String clothesType = clothesGrade.getClothesType();
QueryWrapper<ClothesInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("clothesType", clothesType);
List<ClothesInfo> clothesInfoList = clothesInfoService.list(queryWrapper);
List<ClothesInfoLabelVO> clothesInfoLabelVOS = clothesInfoList.stream().map(clothesInfo -> {
ClothesInfoLabelVO clothesInfoLabelVO = new ClothesInfoLabelVO();
BeanUtils.copyProperties(clothesInfo, clothesInfoLabelVO);
return clothesInfoLabelVO;
}).toList();
return ResultUtils.success(clothesInfoLabelVOS);
}
/**
* 小程序端用户根据服装等级id查询服装详情
* @param commonRequest 服装id
* @return 服装详情信息
*/
@PostMapping("/list/detail")
@Operation(summary = "小程序端用户根据服装等级id查询服装详情", description = "参数：服装id，权限：所有人，方法名：getOneById")
public BaseResponse<ClothesInfoVO> getOneById(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
ClothesInfo clothesInfo = clothesInfoService.getById(id);
ThrowUtils.throwIf(clothesInfo == null, ErrorCode.NOT_FOUND_ERROR, "该服装已被删除");
ClothesInfoVO clothesInfoVO = new ClothesInfoVO();
BeanUtils.copyProperties(clothesInfo, clothesInfoVO);
return ResultUtils.success(clothesInfoVO);
}
}

219
src/main/java/com/cultural/heritage/controller/book/PhotoCategoryController.java Normal file
View File

@ -0,0 +1,219 @@
package com.cultural.heritage.controller.book;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.cultural.heritage.annotation.AuthCheck;
import com.cultural.heritage.common.BaseResponse;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.common.ResultUtils;
import com.cultural.heritage.constant.UserConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.model.dto.CommonRequest;
import com.cultural.heritage.model.dto.CommonStringRequest;
import com.cultural.heritage.model.dto.photoCategory.PhotoCategoryAddRequest;
import com.cultural.heritage.model.dto.photoCategory.PhotoCategoryUpdateRequest;
import com.cultural.heritage.model.entity.PhotoCategory;
import com.cultural.heritage.model.entity.PhotoProducts;
import com.cultural.heritage.model.vo.clothesgrade.PhotoCategoryVO;
import com.cultural.heritage.model.vo.clothesinfo.PhotoProductsVO;
import com.cultural.heritage.service.book.PhotoCategoryService;
import com.cultural.heritage.service.book.PhotoProductsService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
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.List;
@RestController
@RequestMapping("/photoCategory")
@Slf4j
@Tag(name = "写真类别管理模块")
public class PhotoCategoryController {
@Resource
private PhotoCategoryService photoCategoryService;
@Resource
private PhotoProductsService photoProductsService;
/**
* Web端管理员添加写真类别
* @param photoCategoryAddRequest 写真类别添加请求体
* @return 写真类别id
*/
@PostMapping("/add")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员添加写真类别", description = "参数：写真类别添加请求体，权限：管理员(admin, boss)，方法名：addPhotoCategory")
public BaseResponse<Long> addPhotoCategory(@RequestBody PhotoCategoryAddRequest photoCategoryAddRequest) {
if (photoCategoryAddRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
PhotoCategory photoCategory = new PhotoCategory();
BeanUtils.copyProperties(photoCategoryAddRequest, photoCategory);
// 校验
photoCategoryService.validPhotoCategory(photoCategory, false);
boolean save = photoCategoryService.save(photoCategory);
ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR, "写真类别添加失败");
return ResultUtils.success(photoCategory.getId());
}
/**
* Web端管理员更新写真类别
* @param photoCategoryUpdateRequest 写真类别更新请求体
* @return 是否更新成功
*/
@PostMapping("/update")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员更新写真类别", description = "参数：写真类别更新请求体，权限：管理员(admin, boss)，方法名：updatePhotoCategory")
public BaseResponse<Boolean> updatePhotoCategory(@RequestBody PhotoCategoryUpdateRequest photoCategoryUpdateRequest) {
if (photoCategoryUpdateRequest == null || photoCategoryUpdateRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
// 获取原有写真类别名称
Long id = photoCategoryUpdateRequest.getId();
PhotoCategory originPhotoCategory = photoCategoryService.getById(id);
String originName = originPhotoCategory.getName();
// 获取目标写真预约名称
String targetName = photoCategoryUpdateRequest.getName();
// 更新原有写真类别下所有的写真产品类名
UpdateWrapper<PhotoProducts> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("categoryName", originName).set("categoryName", targetName);
boolean update = photoProductsService.update(updateWrapper);
ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "写真产品类名更新失败");
// 更新写真类别名称
PhotoCategory photoCategory = new PhotoCategory();
BeanUtils.copyProperties(photoCategoryUpdateRequest, photoCategory);
// 校验
photoCategoryService.validPhotoCategory(photoCategory, true);
boolean result = photoCategoryService.updateById(photoCategory);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真类别名称更新失败");
return ResultUtils.success(true);
}
/**
* 删除写真类别
* @param commonRequest 写真类别id
* @return 是否删除成功
*/
@PostMapping("/delete")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员删除写真类别", description = "参数：写真类别id，权限：管理员(admin, boss)，方法名：deletePhotoCategory")
public BaseResponse<Boolean> deletePhotoCategory(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
// 删除写真类别之前，先删除该类别下所有产品
PhotoCategory photoCategory = photoCategoryService.getById(id);
QueryWrapper<PhotoProducts> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("categoryName", photoCategory.getName());
List<PhotoProducts> photoProductsList = photoProductsService.list(queryWrapper);
if (!photoProductsList.isEmpty()) {
boolean remove = photoProductsService.removeBatchByIds(photoProductsList);
ThrowUtils.throwIf(!remove, ErrorCode.OPERATION_ERROR, "写真产品批量删除失败");
}
// 删除写真类别
boolean result = photoCategoryService.removeById(id);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真类别删除失败");
return ResultUtils.success(true);
}
/**
* Web端管理员查询写真类别
* @return 写真类别列表
*/
@PostMapping("/list")
@Operation(summary = "Web端管理员查询写真类别", description = "参数：无，权限：web端管理员，方法名：listCategory")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
public BaseResponse<List<PhotoCategoryVO>> listCategory() {
List<PhotoCategory> photoCategoryList = photoCategoryService.list();
List<PhotoCategoryVO> photoCategoryVOS = photoCategoryList.stream().map(photoCategory -> {
PhotoCategoryVO photoCategoryVO = new PhotoCategoryVO();
BeanUtils.copyProperties(photoCategory, photoCategoryVO);
return photoCategoryVO;
}).toList();
return ResultUtils.success(photoCategoryVOS);
}
/**
* 小程序端用户查询写真类别
* @return 写真类别列表
*/
@PostMapping("/list/users")
@Operation(summary = "小程序端用户查询写真类别", description = "参数：无，权限：所有人，方法名：listCategoryByUsers")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
public BaseResponse<List<PhotoCategoryVO>> listCategoryByUsers() {
QueryWrapper<PhotoProducts> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("isShelves", 1);
List<PhotoProducts> photoProductsList = photoProductsService.list(queryWrapper);
List<String> typeNameList = photoProductsList.stream().map(PhotoProducts::getCategoryName).toList();
QueryWrapper<PhotoCategory> categoryWrapper = new QueryWrapper<>();
categoryWrapper.in("name", typeNameList);
List<PhotoCategory> categoryList = photoCategoryService.list(categoryWrapper);
List<PhotoCategoryVO> photoCategoryVOS = categoryList.stream().map(photoCategory -> {
PhotoCategoryVO photoCategoryVO = new PhotoCategoryVO();
BeanUtils.copyProperties(photoCategory, photoCategoryVO);
return photoCategoryVO;
}).toList();
return ResultUtils.success(photoCategoryVOS);
}
/**
* 小程序端用户根据类名查询写真产品
* @param commonStringRequest 写真类名
* @return 写真产品列表
*/
@PostMapping("/list/id")
@Operation(summary = "小程序端用户根据写真类别id查询写真产品", description = "参数：无，权限：所有人，方法名：listPhotoProductsByTypeName")
public BaseResponse<List<PhotoProductsVO>> listPhotoProductsByTypeName(@RequestBody CommonStringRequest commonStringRequest) {
if (commonStringRequest == null || StringUtils.isBlank(commonStringRequest.getType())) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
String categoryName = commonStringRequest.getType();
QueryWrapper<PhotoProducts> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("categoryName", categoryName).eq("isShelves", 1);
List<PhotoProducts> photoProductsList = photoProductsService.list(queryWrapper);
List<PhotoProductsVO> photoProductsVOS = photoProductsList.stream().map(photoProducts -> {
PhotoProductsVO photoProductsVO = new PhotoProductsVO();
BeanUtils.copyProperties(photoProducts, photoProductsVO);
return photoProductsVO;
}).toList();
return ResultUtils.success(photoProductsVOS);
}
}

225
src/main/java/com/cultural/heritage/controller/book/PhotoProductsController.java Normal file
View File

@ -0,0 +1,225 @@
package com.cultural.heritage.controller.book;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cultural.heritage.annotation.AuthCheck;
import com.cultural.heritage.common.BaseResponse;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.common.ResultUtils;
import com.cultural.heritage.constant.UserConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.model.dto.CommonBatchRequest;
import com.cultural.heritage.model.dto.CommonRequest;
import com.cultural.heritage.model.dto.photoProducts.PhotoProductsAddRequest;
import com.cultural.heritage.model.dto.photoProducts.PhotoProductsQueryRequest;
import com.cultural.heritage.model.dto.photoProducts.PhotoProductsUpdateRequest;
import com.cultural.heritage.model.entity.PhotoProducts;
import com.cultural.heritage.model.vo.clothesinfo.PhotoProductsVO;
import com.cultural.heritage.service.book.PhotoCategoryService;
import com.cultural.heritage.service.book.PhotoProductsService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;
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.List;
@RestController
@RequestMapping("/photoProducts")
@Slf4j
@Tag(name = "写真产品管理模块")
public class PhotoProductsController {
@Resource
private PhotoProductsService photoProductsService;
@Resource
private PhotoCategoryService photoCategoryService;
/**
* Web端管理员添加写真产品
* @param photoProductsAddRequest 写真产品添加请求体
* @return 写真产品id
*/
@PostMapping("/add")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web端管理员添加写真产品", description = "参数：写真产品添加请求体，权限：管理员(admin, boss)，方法名：addPhotoProducts")
public BaseResponse<Long> addPhotoProducts(@RequestBody PhotoProductsAddRequest photoProductsAddRequest) {
if (photoProductsAddRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
PhotoProducts photoProducts = new PhotoProducts();
BeanUtils.copyProperties(photoProductsAddRequest, photoProducts);
// 校验
photoProductsService.validPhotoProducts(photoProducts, false);
boolean result = photoProductsService.save(photoProducts);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真产品添加失败");
return ResultUtils.success(photoProducts.getId());
}
/**
* Web管理员更新写真产品
* @param photoProductsUpdateRequest 写真产品更新请求体
* @return 是否更新成功
*/
@PostMapping("/update")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员更新写真产品", description = "参数：服装更新请求体，权限：管理员(admin, boss)，方法名：updatePhotoProducts")
public BaseResponse<Boolean> updatePhotoProducts(@RequestBody PhotoProductsUpdateRequest photoProductsUpdateRequest) {
if (photoProductsUpdateRequest == null || photoProductsUpdateRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
PhotoProducts photoProducts = new PhotoProducts();
BeanUtils.copyProperties(photoProductsUpdateRequest, photoProducts);
// 校验
photoProductsService.validPhotoProducts(photoProducts, true);
boolean result = photoProductsService.updateById(photoProducts);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真产品更新失败");
return ResultUtils.success(true);
}
/**
* Web管理员删除写真产品
* @param commonRequest 写真产品id
* @return 是否删除成功
*/
@PostMapping("/delete")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员删除写真产品", description = "参数：写真产品id，权限：管理员(admin, boss)，方法名：deletePhotoProducts")
public BaseResponse<Boolean> deletePhotoProducts(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
boolean result = photoProductsService.removeById(id);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真产品删除失败");
return ResultUtils.success(true);
}
/**
* Web管理员批量删除写真产品
* @param commonBatchRequest 写真产品id列表
* @return 是否删除成功
*/
@PostMapping("/delBatch")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员批量删除写真产品", description = "参数：写真产品id列表，权限：管理员(admin, boss)，方法名：deletePhotoProducts")
public BaseResponse<Boolean> delBatchPhotoProducts(@RequestBody CommonBatchRequest commonBatchRequest) {
if (commonBatchRequest == null || CollectionUtils.isEmpty(commonBatchRequest.getIdList())) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
List<Long> idList = commonBatchRequest.getIdList();
boolean result = photoProductsService.removeBatchByIds(idList);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR, "写真产品批量删除失败");
return ResultUtils.success(true);
}
/**
* Web管理员分页查询写真产品
* @param photoProductsQueryRequest 写真产品查询请求体
* @return 写真产品列表
*/
@PostMapping("/list/page")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
@Operation(summary = "Web管理员分页查询写真产品", description = "参数：写真产品查询请求体，权限：管理员(admin, boss)，方法名：listPhotoProductsByPage")
public BaseResponse<Page<PhotoProductsVO>> listPhotoProductsByPage(@RequestBody PhotoProductsQueryRequest photoProductsQueryRequest) {
if (photoProductsQueryRequest == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
long current = photoProductsQueryRequest.getCurrent();
long pageSize = photoProductsQueryRequest.getPageSize();
QueryWrapper<PhotoProducts> queryWrapper = photoProductsService.getQueryWrapper(photoProductsQueryRequest);
Page<PhotoProducts> page = photoProductsService.page(new Page<>(current, pageSize), queryWrapper);
// 封装服装类VO
List<PhotoProducts> records = page.getRecords();
List<PhotoProductsVO> photoProductsVOS = records.stream().map(photoProducts -> {
PhotoProductsVO photoProductsVO = new PhotoProductsVO();
BeanUtils.copyProperties(photoProducts, photoProductsVO);
return photoProductsVO;
}).toList();
Page<PhotoProductsVO> voPage = new Page<>();
voPage.setRecords(photoProductsVOS);
voPage.setTotal(page.getTotal());
voPage.setCurrent(page.getCurrent());
voPage.setSize(page.getSize());
voPage.setPages(page.getPages());
return ResultUtils.success(voPage);
}
/**
* 小程序端用户根据id查询写真产品
* @param commonRequest 写真产品id
* @return 写真产品
*/
@PostMapping("/list/detail")
@Operation(summary = "小程序端用户根据id查询写真产品", description = "参数：写真产品id，权限：所有人，方法名：getPhotoProductsById")
public BaseResponse<PhotoProductsVO> getPhotoProductsById(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
Long id = commonRequest.getId();
PhotoProducts photoProducts = photoProductsService.getById(id);
ThrowUtils.throwIf(photoProducts == null || photoProducts.getIsShelves() == 0, ErrorCode.OPERATION_ERROR, "该商品已被删除或者已下架");
PhotoProductsVO photoProductsVO = new PhotoProductsVO();
BeanUtils.copyProperties(photoProductsVO, photoProductsVO);
return ResultUtils.success(photoProductsVO);
}
/**
* Web端管理员上(下)架写真预约产品
* @param commonRequest 写真产品id
* @return 是否更新成功
*/
@PostMapping("/shelves")
@Operation(summary = "Web端管理员上(下)架写真预约产品", description = "参数：写真产品id，权限：管理员(admin, boss)，方法名：updatePhotoProductsShelvesStatus")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
public BaseResponse<Boolean> updatePhotoProductsShelvesStatus(@RequestBody CommonRequest commonRequest) {
if (commonRequest == null || commonRequest.getId() <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
// 获取当前服务类商品的上(下)架状态
Long id = commonRequest.getId();
PhotoProducts photoProducts = photoProductsService.getById(id);
Integer status = photoProducts.getIsShelves() == 0 ? 1 : 0;
UpdateWrapper<PhotoProducts> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("id", id);
updateWrapper.set("isShelves", status);
boolean update = photoProductsService.update(updateWrapper);
ThrowUtils.throwIf(!update, ErrorCode.OPERATION_ERROR, "上架状态更新失败");
return ResultUtils.success(true);
}
}

21
src/main/java/com/cultural/heritage/controller/good/CategoryController.java
View File

@ -191,11 +191,11 @@ public class CategoryController {
/**
* Web端用户查询商品类别
* Web端管理员查询商品类别
* @return 商品类别列表
*/
@PostMapping("/list/web")
@Operation(summary = "Web端用户查询商品类别", description = "参数：无，权限：所有人，方法名：listCategoryOnWeb")
@Operation(summary = "Web端管理员查询商品类别", description = "参数：无，权限：所有人，方法名：listCategoryOnWeb")
@AuthCheck(mustRole = UserConstant.ADMIN_ROLE)
public BaseResponse<List<Category>> listCategoryOnWeb(HttpServletRequest request) {
userService.getLoginUser(request);
@ -214,16 +214,15 @@ public class CategoryController {
@Operation(summary = "小程序端用户查询商品类别", description = "参数：无，权限：所有人，方法名：listCategory")
public BaseResponse<List<Category>> listCategory(HttpServletRequest request) {
userService.getLoginUser(request);
List<Category> list = categoryService.list();
QueryWrapper<Good> goodQueryWrapper = new QueryWrapper<>();
goodQueryWrapper.eq("isShelves", 1);
List<Good> goodList = goodService.list(goodQueryWrapper);
List<String> typeNameList = goodList.stream().map(Good::getType).toList();
QueryWrapper<Category> queryWrapper = new QueryWrapper<>();
queryWrapper.in("typeName", typeNameList);
List<Category> categoryList = categoryService.list(queryWrapper);
List<Category> categoryList = list.stream().filter(category -> {
String typeName = category.getTypeName();
QueryWrapper<Good> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", typeName);
queryWrapper.eq("isShelves", 1);
long count = goodService.count(queryWrapper);
return count != 0;
}).toList();
return ResultUtils.success(categoryList);
}

7
src/main/java/com/cultural/heritage/mapper/ClothesGradeMapper.java
View File

@ -1,7 +0,0 @@
package com.cultural.heritage.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cultural.heritage.model.entity.ClothesGrade;
public interface ClothesGradeMapper extends BaseMapper<ClothesGrade> {
}

7
src/main/java/com/cultural/heritage/mapper/ClothesInfoMapper.java
View File

@ -1,7 +0,0 @@
package com.cultural.heritage.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cultural.heritage.model.entity.ClothesInfo;
public interface ClothesInfoMapper extends BaseMapper<ClothesInfo> {
}

7
src/main/java/com/cultural/heritage/mapper/PhotoCategoryMapper.java Normal file
View File

@ -0,0 +1,7 @@
package com.cultural.heritage.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cultural.heritage.model.entity.PhotoCategory;
public interface PhotoCategoryMapper extends BaseMapper<PhotoCategory> {
}

7
src/main/java/com/cultural/heritage/mapper/PhotoProductsMapper.java Normal file
View File

@ -0,0 +1,7 @@
package com.cultural.heritage.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cultural.heritage.model.entity.PhotoProducts;
public interface PhotoProductsMapper extends BaseMapper<PhotoProducts> {
}

51
src/main/java/com/cultural/heritage/model/dto/clothesgrade/ClothesGradeAddRequest.java
View File

@ -1,51 +0,0 @@
package com.cultural.heritage.model.dto.clothesgrade;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "服装等级添加请求体", requiredProperties = {"clothesType", "image", "minPrice", "maxPrice", "brief"})
public class ClothesGradeAddRequest implements Serializable {
/**
* 类别名称
*/
@Schema(description = "类别名称", example = "简约风尚")
private String clothesType;
/**
* 商品图片
*/
@Schema(description = "商品图片", example = "http://xxx.png")
private String image;
/**
* 最低价格
*/
@Schema(description = "最低价格", example = "80.00")
private BigDecimal minPrice;
/**
* 最高价格
*/
@Schema(description = "最高价格", example = "160")
private BigDecimal maxPrice;
/**
* 服装价位简介
*/
@Schema(description = "服装价位简介", example = "传承非遗之美，简约演绎经典")
private String brief;
@Serial
private static final long serialVersionUID = 1L;
}

59
src/main/java/com/cultural/heritage/model/dto/clothesgrade/ClothesGradeUpdateRequest.java
View File

@ -1,59 +0,0 @@
package com.cultural.heritage.model.dto.clothesgrade;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "服装等级更新请求体")
public class ClothesGradeUpdateRequest implements Serializable {
/**
* 服装等级id
*/
@Schema(description = "服装等级id", example = "2")
private Long id;
/**
* 类别名称
*/
@Schema(description = "类别名称", example = "简约风尚")
private String clothesType;
/**
* 商品图片
*/
@Schema(description = "商品图片", example = "http://xxx.png")
private String image;
/**
* 最低价格
*/
@Schema(description = "最低价格", example = "80.00")
private BigDecimal minPrice;
/**
* 最高价格
*/
@Schema(description = "最高价格", example = "160")
private BigDecimal maxPrice;
/**
* 服装价位简介
*/
@Schema(description = "服装价位简介", example = "传承非遗之美，简约演绎经典")
private String brief;
@Serial
private static final long serialVersionUID = 1L;
}

62
src/main/java/com/cultural/heritage/model/dto/clothesinfo/ClothesInfoAddRequest.java
View File

@ -1,62 +0,0 @@
package com.cultural.heritage.model.dto.clothesinfo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "服装添加请求体", requiredProperties = {"name", "image", "effectImg", "intro", "price", "clothesType"})
public class ClothesInfoAddRequest implements Serializable {
/**
* 服装名称
*/
@Schema(description = "服装名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 服装图片
*/
@Schema(description = "服装图片", example = "https://www.xxx.jpg")
private String image;
/**
* 服装效果图
*/
@Schema(description = "服装效果图", example = "https://www.xxx.jpg;https://www.xxx.png")
private String effectImg;
/**
* 服装简介
*/
@Schema(description = "服装简介", example = "用上等丝绸，质地细腻、柔软且富有光泽，触感极佳。统手工刺绣技艺，每一针每一线都凝聚着匠人的心血与智慧，")
private String intro;
/**
* 服装价格
*/
@Schema(description = "服装价格", example = "100.00")
private BigDecimal price;
/**
* 所属服装等级
*/
@Schema(description = "所属服装等级", example = "简约风尚")
private String clothesType;
@Serial
private static final long serialVersionUID = 1L;
}

56
src/main/java/com/cultural/heritage/model/dto/clothesinfo/ClothesInfoQueryRequest.java
View File

@ -1,56 +0,0 @@
package com.cultural.heritage.model.dto.clothesinfo;
import com.cultural.heritage.common.PageRequest;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "服装查询请求体", requiredProperties = {"current", "pageSize", "sortField"})
public class ClothesInfoQueryRequest extends PageRequest implements Serializable {
/**
* 服装id
*/
@Schema(description = "服装id", example = "2")
private Long id;
/**
* 服装名称
*/
@Schema(description = "服装名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 最低价格
*/
@Schema(description = "最低价格", example = "100.00")
private BigDecimal minPrice;
/**
* 最高价格
*/
@Schema(description = "最高价格", example = "200.00")
private BigDecimal maxPrice;
/**
* 所属服装等级
*/
@Schema(description = "所属服装等级", example = "简约风尚")
private String clothesType;
@Serial
private static final long serialVersionUID = 1L;
}

67
src/main/java/com/cultural/heritage/model/dto/clothesinfo/ClothesInfoUpdateRequest.java
View File

@ -1,67 +0,0 @@
package com.cultural.heritage.model.dto.clothesinfo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "服装添加请求体", requiredProperties = {"id", "name", "image", "effectImg", "intro", "price", "clothesType"})
public class ClothesInfoUpdateRequest implements Serializable {
/**
* 服装id
*/
@Schema(description = "服装id", example = "1")
private Long id;
/**
* 服装名称
*/
@Schema(description = "服装名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 服装图片
*/
@Schema(description = "服装图片", example = "https://www.xxx.jpg")
private String image;
/**
* 服装效果图
*/
@Schema(description = "服装效果图", example = "https://www.xxx.jpg;https://www.xxx.png")
private String effectImg;
/**
* 服装简介
*/
@Schema(description = "服装简介", example = "用上等丝绸，质地细腻、柔软且富有光泽，触感极佳。统手工刺绣技艺，每一针每一线都凝聚着匠人的心血与智慧，")
private String intro;
/**
* 服装价格
*/
@Schema(description = "服装价格", example = "100.00")
private BigDecimal price;
/**
* 所属服装等级
*/
@Schema(description = "所属服装等级", example = "简约风尚")
private String clothesType;
@Serial
private static final long serialVersionUID = 1L;
}

2
src/main/java/com/cultural/heritage/model/dto/good/GoodAddRequest.java
View File

@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@ -74,6 +75,7 @@ public class GoodAddRequest implements Serializable {
private String festivalName;
@Serial
@TableField(exist = false)
private static final long serialVersionUID = 1L;
}

24
src/main/java/com/cultural/heritage/model/dto/photoCategory/PhotoCategoryAddRequest.java Normal file
View File

@ -0,0 +1,24 @@
package com.cultural.heritage.model.dto.photoCategory;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@Data
@Schema(description = "写真类别添加请求体", requiredProperties = {"name"})
public class PhotoCategoryAddRequest implements Serializable {
/**
* 类别名称
*/
@Schema(description = "写真类别名称", example = "简约风尚")
private String name;
@Serial
private static final long serialVersionUID = 1L;
}

31
src/main/java/com/cultural/heritage/model/dto/photoCategory/PhotoCategoryUpdateRequest.java Normal file
View File

@ -0,0 +1,31 @@
package com.cultural.heritage.model.dto.photoCategory;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@Data
@Schema(description = "写真类别更新请求体", requiredProperties = {"id", "name"})
public class PhotoCategoryUpdateRequest implements Serializable {
/**
* 写真类别id
*/
@Schema(description = "写真类别id", example = "2")
private Long id;
/**
* 写真类别名称
*/
@Schema(description = "写真类别名称", example = "简约风尚")
private String name;
@Serial
private static final long serialVersionUID = 1L;
}

85
src/main/java/com/cultural/heritage/model/dto/photoProducts/PhotoProductsAddRequest.java Normal file
View File

@ -0,0 +1,85 @@
package com.cultural.heritage.model.dto.photoProducts;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "写真产品添加请求体", requiredProperties =
{"name", "introImg", "effectImg", "detailImg", "minNumber", "maxNumber", "shotScene", "price", "categoryId"})
public class PhotoProductsAddRequest implements Serializable {
/**
* 产品名称
*/
@Schema(description = "产品名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 介绍图片
*/
@Schema(description = "介绍图片", example = "https://www.xxx.jpg")
private String introImg;
/**
* 效果图片
*/
@Schema(description = "效果图片", example = "https://www.xxx.jpg;https://www.xxx.png")
private String [] effectImg;
/**
* 详情图片
*/
@Schema(description = "详情图片", example = "https://www.xxx.jpg;https://www.xxx.png")
private String detailImg;
/**
* 最小预约人数
*/
@Schema(description = "最小预约人数", example = "4")
private Integer minNumber;
/**
* 最大预约人数
*/
@Schema(description = "最大预约人数", example = "10")
private Integer maxNumber;
/**
* 拍摄场景
*/
@Schema(description = "拍摄场景", example = "室内")
private String shotScene;
/**
* 产品价格
*/
@Schema(description = "产品价格", example = "100.00")
private BigDecimal price;
/**
* 写真类别名称
*/
@Schema(description = "写真类别名称", example = "5")
private String categoryName;
@Serial
private static final long serialVersionUID = 1L;
}

43
src/main/java/com/cultural/heritage/model/dto/photoProducts/PhotoProductsQueryRequest.java Normal file
View File

@ -0,0 +1,43 @@
package com.cultural.heritage.model.dto.photoProducts;
import com.cultural.heritage.common.PageRequest;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "写真产品查询请求体", requiredProperties = {"current", "pageSize", "sortField"})
public class PhotoProductsQueryRequest extends PageRequest implements Serializable {
/**
* 服装id
*/
@Schema(description = "服装id", example = "2")
private Long id;
/**
* 服装名称
*/
@Schema(description = "服装名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 写真类别名称
*/
@Schema(description = "写真类别名称", example = "3")
private String categoryName;
@Serial
private static final long serialVersionUID = 1L;
}

90
src/main/java/com/cultural/heritage/model/dto/photoProducts/PhotoProductsUpdateRequest.java Normal file
View File

@ -0,0 +1,90 @@
package com.cultural.heritage.model.dto.photoProducts;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
@Schema(description = "写真产品更新请求体", requiredProperties =
{"id", "name", "introImg", "effectImg", "detailImg", "minNumber", "maxNumber", "shotScene", "price", "categoryId"})
public class PhotoProductsUpdateRequest implements Serializable {
/**
* 产品id
*/
@Schema(description = "产品id", example = "1")
private Long id;
/**
* 产品名称
*/
@Schema(description = "产品名称", example = "彩绣菊花纹刺绣长袍")
private String name;
/**
* 介绍图片
*/
@Schema(description = "介绍图片", example = "https://www.xxx.jpg")
private String introImg;
/**
* 效果图片
*/
@Schema(description = "效果图片", example = "https://www.xxx.jpg;https://www.xxx.png")
private String [] effectImg;
/**
* 详情图片
*/
@Schema(description = "详情图片", example = "https://www.xxx.jpg;https://www.xxx.png")
private String detailImg;
/**
* 最小预约人数
*/
@Schema(description = "最小预约人数", example = "4")
private Integer minNumber;
/**
* 最大预约人数
*/
@Schema(description = "最大预约人数", example = "10")
private Integer maxNumber;
/**
* 拍摄场景
*/
@Schema(description = "拍摄场景", example = "室内")
private String shotScene;
/**
* 产品价格
*/
@Schema(description = "产品价格", example = "100.00")
private BigDecimal price;
/**
* 写真类别名称
*/
@Schema(description = "写真类别名称", example = "5")
private String categoryName;
@Serial
private static final long serialVersionUID = 1L;
}

37
src/main/java/com/cultural/heritage/model/entity/ClothesGrade.java → src/main/java/com/cultural/heritage/model/entity/PhotoCategory.java
View File

@ -7,21 +7,20 @@ import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* 服装等级
* @TableName clothes_grade
* 写真类别
* @TableName photo_category
*/
@Data
@TableName("clothes_grade")
public class ClothesGrade implements Serializable {
@TableName("photo_category")
public class PhotoCategory implements Serializable {
/**
* 服装等级id
* 类别id
*/
@TableId(type = IdType.AUTO)
private Long id;
@ -30,31 +29,7 @@ public class ClothesGrade implements Serializable {
/**
* 类别名称
*/
private String clothesType;
/**
* 商品图片
*/
private String image;
/**
* 最低价格
*/
private BigDecimal minPrice;
/**
* 最高价格
*/
private BigDecimal maxPrice;
/**
* 服装价位简介
*/
private String brief;
private String name;
/**

54
src/main/java/com/cultural/heritage/model/entity/ClothesInfo.java → src/main/java/com/cultural/heritage/model/entity/PhotoProducts.java
View File

@ -11,56 +11,80 @@ import java.math.BigDecimal;
import java.util.Date;
/**
* 服装信息表
* @TableName clothes_info
* 写真产品
* @TableName photo_products
*/
@Data
@TableName("clothes_info")
public class ClothesInfo implements Serializable {
@TableName("photo_products")
public class PhotoProducts extends Good implements Serializable {
/**
* 服装id
* 产品id
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 服装名称
* 产品名称
*/
private String name;
/**
* 服装图片
* 介绍图片
*/
private String image;
private String introImg;
/**
* 服装效果图
* 效果图
*/
private String effectImg;
private String [] effectImg;
/**
* 服装简介
* 详情图片
*/
private String intro;
private String detailImg;
/**
* 服装价格
* 最小预约人数
*/
private Integer minNumber;
/**
* 最大预约人数
*/
private Integer maxNumber;
/**
* 拍摄场景
*/
private String shotScene;
/**
* 产品价格
*/
private BigDecimal price;
/**
* 所属服装等级
* 写真类别名称
*/
private String clothesType;
private String categoryName;
/**
* 是否上架
*/
private Integer isShelves;
/**

52
src/main/java/com/cultural/heritage/model/vo/clothesgrade/ClothesGradeVO.java
View File

@ -1,52 +0,0 @@
package com.cultural.heritage.model.vo.clothesgrade;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
public class ClothesGradeVO implements Serializable {
/**
* 服装等级id
*/
private Long id;
/**
* 类别名称
*/
private String clothesType;
/**
* 商品图片
*/
private String image;
/**
* 最低价格
*/
private BigDecimal minPrice;
/**
* 最高价格
*/
private BigDecimal maxPrice;
/**
* 服装价位简介
*/
private String brief;
@Serial
private static final long serialVersionUID = 1L;
}

26
src/main/java/com/cultural/heritage/model/vo/clothesgrade/PhotoCategoryVO.java Normal file
View File

@ -0,0 +1,26 @@
package com.cultural.heritage.model.vo.clothesgrade;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
@Data
public class PhotoCategoryVO implements Serializable {
/**
* 类别id
*/
private Long id;
/**
* 类别名称
*/
private String name;
@Serial
private static final long serialVersionUID = 1L;
}

57
src/main/java/com/cultural/heritage/model/vo/clothesinfo/ClothesInfoVO.java
View File

@ -1,57 +0,0 @@
package com.cultural.heritage.model.vo.clothesinfo;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
public class ClothesInfoVO implements Serializable {
/**
* 服装id
*/
private Long id;
/**
* 服装名称
*/
private String name;
/**
* 服装图片
*/
private String image;
/**
* 服装效果图
*/
private String effectImg;
/**
* 服装简介
*/
private String intro;
/**
* 服装价格
*/
private BigDecimal price;
/**
* 所属服装等级
*/
private String clothesType;
@Serial
private static final long serialVersionUID = 1L;
}

81
src/main/java/com/cultural/heritage/model/vo/clothesinfo/PhotoProductsVO.java Normal file
View File

@ -0,0 +1,81 @@
package com.cultural.heritage.model.vo.clothesinfo;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
@Data
public class PhotoProductsVO implements Serializable {
/**
* 产品id
*/
private Long id;
/**
* 产品名称
*/
private String name;
/**
* 介绍图片
*/
private String introImg;
/**
* 效果图
*/
private String [] effectImg;
/**
* 详情图片
*/
private String detailImg;
/**
* 最小预约人数
*/
private Integer minNumber;
/**
* 最大预约人数
*/
private Integer maxNumber;
/**
* 拍摄场景
*/
private String shotScene;
/**
* 产品价格
*/
private BigDecimal price;
/**
* 写真类别名称
*/
private String categoryName;
/**
* 是否上架
*/
private Integer isShelves;
@Serial
private static final long serialVersionUID = 1L;
}

19
src/main/java/com/cultural/heritage/service/book/ClothesGradeService.java
View File

@ -1,19 +0,0 @@
package com.cultural.heritage.service.book;
import com.baomidou.mybatisplus.extension.service.IService;
import com.cultural.heritage.model.entity.ClothesGrade;
public interface ClothesGradeService extends IService<ClothesGrade> {
/**
* 校验
*/
void validClothesGrade(ClothesGrade clothesGrade, boolean update);
/**
* 删除当前服装等级下的所有服装
*/
void deleteCurrentAllClothes(Long id);
}

20
src/main/java/com/cultural/heritage/service/book/ClothesInfoService.java
View File

@ -1,20 +0,0 @@
package com.cultural.heritage.service.book;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.cultural.heritage.model.dto.clothesinfo.ClothesInfoQueryRequest;
import com.cultural.heritage.model.entity.ClothesInfo;
public interface ClothesInfoService extends IService<ClothesInfo> {
/**
* 校验
*/
void validClothesInfo(ClothesInfo clothesInfo, boolean update);
/**
* 获取查询条件
*/
QueryWrapper<ClothesInfo> getQueryWrapper(ClothesInfoQueryRequest clothesInfoQueryRequest);
}

14
src/main/java/com/cultural/heritage/service/book/PhotoCategoryService.java Normal file
View File

@ -0,0 +1,14 @@
package com.cultural.heritage.service.book;
import com.baomidou.mybatisplus.extension.service.IService;
import com.cultural.heritage.model.entity.PhotoCategory;
public interface PhotoCategoryService extends IService<PhotoCategory> {
/**
* 校验
*/
void validPhotoCategory(PhotoCategory photoCategory, boolean update);
}

20
src/main/java/com/cultural/heritage/service/book/PhotoProductsService.java Normal file
View File

@ -0,0 +1,20 @@
package com.cultural.heritage.service.book;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.cultural.heritage.model.dto.photoProducts.PhotoProductsQueryRequest;
import com.cultural.heritage.model.entity.PhotoProducts;
public interface PhotoProductsService extends IService<PhotoProducts> {
/**
* 校验
*/
void validPhotoProducts(PhotoProducts photoProducts, boolean update);
/**
* 获取查询条件
*/
QueryWrapper<PhotoProducts> getQueryWrapper(PhotoProductsQueryRequest photoProductsQueryRequest);
}

87
src/main/java/com/cultural/heritage/service/book/impl/ClothesGradeServiceImpl.java
View File

@ -1,87 +0,0 @@
package com.cultural.heritage.service.book.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.mapper.ClothesGradeMapper;
import com.cultural.heritage.model.entity.ClothesGrade;
import com.cultural.heritage.model.entity.ClothesInfo;
import com.cultural.heritage.service.book.ClothesGradeService;
import com.cultural.heritage.service.book.ClothesInfoService;
import jakarta.annotation.Resource;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
@Service
public class ClothesGradeServiceImpl extends ServiceImpl<ClothesGradeMapper, ClothesGrade> implements ClothesGradeService {
@Resource
private ClothesInfoService clothesInfoService;
/**
* 校验
*/
@Override
public void validClothesGrade(ClothesGrade clothesGrade, boolean update) {
Long id = clothesGrade.getId();
String clothesType = clothesGrade.getClothesType();
String image = clothesGrade.getImage();
BigDecimal minPrice = clothesGrade.getMinPrice();
BigDecimal maxPrice = clothesGrade.getMaxPrice();
String brief = clothesGrade.getBrief();
if (update) {
if (id == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数id错误");
}
}
if (ObjectUtils.isEmpty(minPrice) || minPrice.compareTo(BigDecimal.ZERO) <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "最低价格参数错误");
}
if (ObjectUtils.isEmpty(maxPrice) || maxPrice.compareTo(BigDecimal.ZERO) <= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "最高价格参数错误");
}
if (minPrice.compareTo(maxPrice) >= 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "最低价格不能高于最高价格");
}
if (StringUtils.isAnyBlank(clothesType, image, brief)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
QueryWrapper<ClothesGrade> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("clothesType", clothesType);
if (update) {
queryWrapper.ne("id", id);
Long count = this.baseMapper.selectCount(queryWrapper);
ThrowUtils.throwIf(count > 0, ErrorCode.OPERATION_ERROR, "当前服装等级已存在");
} else {
Long count = this.baseMapper.selectCount(queryWrapper);
ThrowUtils.throwIf(count > 0, ErrorCode.OPERATION_ERROR, "不能重复添加服装等级");
}
}
/**
* 删除当前服装等级下的所有服装
*/
@Override
public void deleteCurrentAllClothes(Long id) {
ClothesGrade clothesGrade = this.getById(id);
String clothesType = clothesGrade.getClothesType();
QueryWrapper<ClothesInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("clothesType", clothesType);
List<ClothesInfo> list = clothesInfoService.list(queryWrapper);
// 如果当前服装等级下存在服装，就删掉
if (!ObjectUtils.isEmpty(list)) {
boolean result = clothesInfoService.removeBatchByIds(list);
ThrowUtils.throwIf(!result, ErrorCode.OPERATION_ERROR);
}
}
}

72
src/main/java/com/cultural/heritage/service/book/impl/ClothesInfoServiceImpl.java
View File

@ -1,72 +0,0 @@
package com.cultural.heritage.service.book.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.constant.CommonConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.mapper.ClothesInfoMapper;
import com.cultural.heritage.model.dto.clothesinfo.ClothesInfoQueryRequest;
import com.cultural.heritage.model.entity.ClothesInfo;
import com.cultural.heritage.service.book.ClothesInfoService;
import com.cultural.heritage.utils.SqlUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Service
public class ClothesInfoServiceImpl extends ServiceImpl<ClothesInfoMapper, ClothesInfo> implements ClothesInfoService {
/**
* 校验
*/
@Override
public void validClothesInfo(ClothesInfo clothesInfo, boolean update) {
Long id = clothesInfo.getId();
String name = clothesInfo.getName();
String image = clothesInfo.getImage();
String effectImg = clothesInfo.getEffectImg();
String intro = clothesInfo.getIntro();
BigDecimal price = clothesInfo.getPrice();
String clothesType = clothesInfo.getClothesType();
if (update) {
if (id == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR);
}
}
if (StringUtils.isAnyBlank(name, image, effectImg, intro, clothesType)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数不全");
}
if (ObjectUtils.isEmpty(price) || price.compareTo(BigDecimal.ZERO) < 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "价格参数错误");
}
}
/**
* 获取查询条件
*/
@Override
public QueryWrapper<ClothesInfo> getQueryWrapper(ClothesInfoQueryRequest clothesInfoQueryRequest) {
Long id = clothesInfoQueryRequest.getId();
String name = clothesInfoQueryRequest.getName();
BigDecimal minPrice = clothesInfoQueryRequest.getMinPrice();
BigDecimal maxPrice = clothesInfoQueryRequest.getMaxPrice();
String clothesType = clothesInfoQueryRequest.getClothesType();
String sortField = clothesInfoQueryRequest.getSortField();
String sortOrder = clothesInfoQueryRequest.getSortOrder();
QueryWrapper<ClothesInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(id != null, "id", id);
queryWrapper.like(StringUtils.isNotBlank(name), "name", name);
queryWrapper.eq(StringUtils.isNotBlank(clothesType), "clothesType", clothesType);
queryWrapper.ge(ObjectUtils.isNotEmpty(minPrice), "price", minPrice);
queryWrapper.le(ObjectUtils.isNotEmpty(maxPrice), "price", maxPrice);
queryWrapper.orderBy(SqlUtils.validSortField(sortField), sortOrder.equals(CommonConstant.SORT_ORDER_ASC),
sortField);
return queryWrapper;
}
}

55
src/main/java/com/cultural/heritage/service/book/impl/PhotoCategoryServiceImpl.java Normal file
View File

@ -0,0 +1,55 @@
package com.cultural.heritage.service.book.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.exception.ThrowUtils;
import com.cultural.heritage.mapper.PhotoCategoryMapper;
import com.cultural.heritage.model.entity.PhotoCategory;
import com.cultural.heritage.service.book.PhotoCategoryService;
import com.cultural.heritage.service.book.PhotoProductsService;
import jakarta.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
@Service
public class PhotoCategoryServiceImpl extends ServiceImpl<PhotoCategoryMapper, PhotoCategory> implements PhotoCategoryService {
@Resource
private PhotoProductsService clothesInfoService;
/**
* 校验
*/
@Override
public void validPhotoCategory(PhotoCategory photoCategory, boolean update) {
Long id = photoCategory.getId();
String name = photoCategory.getName();
if (update) {
if (id == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数id错误");
}
}
if (StringUtils.isBlank(name)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "类别参数错误");
}
QueryWrapper<PhotoCategory> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", name);
if (update) {
queryWrapper.ne("id", id);
Long count = this.baseMapper.selectCount(queryWrapper);
ThrowUtils.throwIf(count > 0, ErrorCode.OPERATION_ERROR, "当前写真类名已存在");
} else {
Long count = this.baseMapper.selectCount(queryWrapper);
ThrowUtils.throwIf(count > 0, ErrorCode.OPERATION_ERROR, "不能重复添加写真类名");
}
}
}

82
src/main/java/com/cultural/heritage/service/book/impl/PhotoProductsServiceImpl.java Normal file
View File

@ -0,0 +1,82 @@
package com.cultural.heritage.service.book.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cultural.heritage.common.ErrorCode;
import com.cultural.heritage.constant.CommonConstant;
import com.cultural.heritage.exception.BusinessException;
import com.cultural.heritage.mapper.PhotoProductsMapper;
import com.cultural.heritage.model.dto.photoProducts.PhotoProductsQueryRequest;
import com.cultural.heritage.model.entity.PhotoProducts;
import com.cultural.heritage.service.book.PhotoProductsService;
import com.cultural.heritage.utils.SqlUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Service
public class PhotoProductsServiceImpl extends ServiceImpl<PhotoProductsMapper, PhotoProducts> implements PhotoProductsService {
/**
* 校验
*/
@Override
public void validPhotoProducts(PhotoProducts photoProducts, boolean update) {
Long id = photoProducts.getId();
String name = photoProducts.getName();
String introImg = photoProducts.getIntroImg();
String [] effectImg = photoProducts.getEffectImg();
String detailImg = photoProducts.getDetailImg();
Integer minNumber = photoProducts.getMinNumber();
Integer maxNumber = photoProducts.getMaxNumber();
String shotScene = photoProducts.getShotScene();
BigDecimal price = photoProducts.getPrice();
String categoryName = photoProducts.getCategoryName();
if (update) {
if (id == null) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "id参错误");
}
}
if (StringUtils.isAnyBlank(name, introImg, detailImg, shotScene, categoryName)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "参数不全");
}
if (ArrayUtils.isEmpty(effectImg)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "效果图片参数为空");
}
if (ObjectUtils.anyNull(minNumber, maxNumber)) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "预约人数参数错误");
}
if (minNumber > maxNumber) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "最小预约人数大于最大预约人数");
}
if (ObjectUtils.isEmpty(price) || price.compareTo(BigDecimal.ZERO) < 0) {
throw new BusinessException(ErrorCode.PARAMS_ERROR, "价格参数错误");
}
}
/**
* 获取查询条件
*/
@Override
public QueryWrapper<PhotoProducts> getQueryWrapper(PhotoProductsQueryRequest photoProductsQueryRequest) {
Long id = photoProductsQueryRequest.getId();
String name = photoProductsQueryRequest.getName();
String categoryName = photoProductsQueryRequest.getCategoryName();
String sortField = photoProductsQueryRequest.getSortField();
String sortOrder = photoProductsQueryRequest.getSortOrder();
QueryWrapper<PhotoProducts> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(id != null, "id", id);
queryWrapper.like(StringUtils.isNotBlank(name), "name", name);
queryWrapper.eq(StringUtils.isNotBlank(categoryName), "categoryName", categoryName);
queryWrapper.orderBy(SqlUtils.validSortField(sortField), sortOrder.equals(CommonConstant.SORT_ORDER_ASC),
sortField);
return queryWrapper;
}
}

2
src/main/resources/mapper/ClothesInfoMapper.xml → src/main/resources/mapper/PhotoCategoryMapper.xml
View File

@ -2,6 +2,6 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cultural.heritage.mapper.ClothesInfoMapper">
<mapper namespace="com.cultural.heritage.mapper.PhotoCategoryMapper">
</mapper>

2
src/main/resources/mapper/ClothesGradeMapper.xml → src/main/resources/mapper/PhotoProductsMapper.xml
View File

@ -2,6 +2,6 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cultural.heritage.mapper.ClothesGradeMapper">
<mapper namespace="com.cultural.heritage.mapper.PhotoProductsMapper">
</mapper>