package com.tcm.training.admin.live.service;
|
|
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.tcm.training.admin.common.PageResponse;
|
import com.tcm.training.admin.live.dto.LiveCourseCategorySaveRequest;
|
import com.tcm.training.admin.live.entity.LiveCourseCategory;
|
import com.tcm.training.admin.live.mapper.LiveCourseCategoryMapper;
|
import com.tcm.training.admin.live.vo.LiveCourseCategoryDetailVO;
|
import com.tcm.training.admin.live.vo.LiveCourseCategoryItemVO;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
@Service
|
public class LiveCourseCategoryAppService {
|
|
public static final String TYPE_LEVEL = "LEVEL";
|
public static final String TYPE_DIFFICULTY = "DIFFICULTY";
|
|
private final LiveCourseCategoryMapper liveCourseCategoryMapper;
|
|
public LiveCourseCategoryAppService(LiveCourseCategoryMapper liveCourseCategoryMapper) {
|
this.liveCourseCategoryMapper = liveCourseCategoryMapper;
|
}
|
|
public PageResponse<LiveCourseCategoryItemVO> page(int page, int pageSize, String type) {
|
String normalizedType = normalizeType(type);
|
LambdaQueryWrapper<LiveCourseCategory> qw = new LambdaQueryWrapper<LiveCourseCategory>()
|
.eq(LiveCourseCategory::getType, normalizedType)
|
.orderByAsc(LiveCourseCategory::getSort)
|
.orderByAsc(LiveCourseCategory::getId);
|
IPage<LiveCourseCategory> p = liveCourseCategoryMapper.selectPage(new Page<LiveCourseCategory>(page, pageSize), qw);
|
List<LiveCourseCategoryItemVO> list = new ArrayList<LiveCourseCategoryItemVO>();
|
for (LiveCourseCategory item : p.getRecords()) {
|
list.add(new LiveCourseCategoryItemVO(
|
item.getId(),
|
item.getType(),
|
item.getName(),
|
item.getSort(),
|
item.getCreatedAt()
|
));
|
}
|
return PageResponse.of(list, p.getTotal(), p.getCurrent(), p.getSize());
|
}
|
|
public LiveCourseCategoryDetailVO detail(Long id) {
|
return toDetailVO(requireCategory(id));
|
}
|
|
@Transactional
|
public LiveCourseCategoryDetailVO create(String type, LiveCourseCategorySaveRequest req) {
|
String normalizedType = normalizeType(type);
|
String name = normalizeName(req.getName());
|
validateUniqueName(normalizedType, name, null);
|
|
LiveCourseCategory entity = new LiveCourseCategory();
|
entity.setType(normalizedType);
|
entity.setName(name);
|
entity.setSort(resolveSort(req.getSort()));
|
entity.setDeleted(0);
|
liveCourseCategoryMapper.insert(entity);
|
return detail(entity.getId());
|
}
|
|
@Transactional
|
public LiveCourseCategoryDetailVO update(Long id, LiveCourseCategorySaveRequest req) {
|
LiveCourseCategory entity = requireCategory(id);
|
String name = normalizeName(req.getName());
|
validateUniqueName(entity.getType(), name, id);
|
|
entity.setName(name);
|
entity.setSort(resolveSort(req.getSort()));
|
liveCourseCategoryMapper.updateById(entity);
|
return detail(id);
|
}
|
|
@Transactional
|
public void delete(Long id) {
|
requireCategory(id);
|
liveCourseCategoryMapper.deleteById(id);
|
}
|
|
private LiveCourseCategory requireCategory(Long id) {
|
LiveCourseCategory entity = liveCourseCategoryMapper.selectOne(new LambdaQueryWrapper<LiveCourseCategory>()
|
.eq(LiveCourseCategory::getId, id)
|
.eq(LiveCourseCategory::getDeleted, 0)
|
.last("limit 1"));
|
if (entity == null) {
|
throw new IllegalArgumentException("分类不存在");
|
}
|
return entity;
|
}
|
|
private void validateUniqueName(String type, String name, Long excludeId) {
|
LambdaQueryWrapper<LiveCourseCategory> qw = new LambdaQueryWrapper<LiveCourseCategory>()
|
.eq(LiveCourseCategory::getType, type)
|
.eq(LiveCourseCategory::getName, name)
|
.eq(LiveCourseCategory::getDeleted, 0);
|
if (excludeId != null) {
|
qw.ne(LiveCourseCategory::getId, excludeId);
|
}
|
Long count = liveCourseCategoryMapper.selectCount(qw);
|
if (count != null && count > 0) {
|
throw new IllegalArgumentException(resolveLabel(type) + "名称已存在");
|
}
|
}
|
|
private String normalizeType(String type) {
|
if (type == null) {
|
throw new IllegalArgumentException("分类类型不能为空");
|
}
|
String normalized = type.trim().toUpperCase();
|
if (!TYPE_LEVEL.equals(normalized) && !TYPE_DIFFICULTY.equals(normalized)) {
|
throw new IllegalArgumentException("分类类型不合法");
|
}
|
return normalized;
|
}
|
|
private String normalizeName(String name) {
|
String normalized = name == null ? "" : name.trim();
|
if (normalized.isEmpty()) {
|
throw new IllegalArgumentException("请输入分类名称");
|
}
|
return normalized;
|
}
|
|
private Integer resolveSort(Integer sort) {
|
return sort == null ? 0 : sort;
|
}
|
|
private String resolveLabel(String type) {
|
return TYPE_LEVEL.equals(type) ? "养生等级" : "难度";
|
}
|
|
private LiveCourseCategoryDetailVO toDetailVO(LiveCourseCategory entity) {
|
LiveCourseCategoryDetailVO vo = new LiveCourseCategoryDetailVO();
|
vo.setId(entity.getId());
|
vo.setType(entity.getType());
|
vo.setName(entity.getName());
|
vo.setSort(entity.getSort());
|
vo.setCreatedAt(entity.getCreatedAt());
|
vo.setUpdatedAt(entity.getUpdatedAt());
|
return vo;
|
}
|
}
|
